package com.css.zfzx.fwsjcj.modules.report.service.Impl;

import com.css.bpm.platform.api.local.PlatformAPI;
import com.css.bpm.platform.components.attach.repository.entity.SysAttachmentEntity;
import com.css.bpm.platform.org.user.repository.entity.UserEntity;
import com.css.bpm.platform.utils.PlatformObjectUtils;
import com.css.bpm.platform.utils.PlatformSessionUtils;
import com.css.zfzx.fwsjcj.commen.util.*;
import com.css.zfzx.fwsjcj.config.image.ConfigBeanValue;
import com.css.zfzx.fwsjcj.modules.analysis.vo.AnalysisQueryVo;
import com.css.zfzx.fwsjcj.modules.group.entity.FwGroupEntity;
import com.css.zfzx.fwsjcj.modules.group.entity.FwGroupUserEntity;
import com.css.zfzx.fwsjcj.modules.group.service.FwGroupService;
import com.css.zfzx.fwsjcj.modules.group.service.FwGroupUserService;
import com.css.zfzx.fwsjcj.modules.report.service.XCReportService;
import com.css.zfzx.fwsjcj.modules.structure.entity.*;
import com.css.zfzx.fwsjcj.modules.structure.service.*;
import com.css.zfzx.fwsjcj.modules.taskmanage.task.entity.FwTaskEntity;
import com.css.zfzx.fwsjcj.modules.taskmanage.task.repository.TaskQueryRepsitory;
import com.css.zfzx.fwsjcj.modules.taskmanage.task.service.TaskService;
import com.css.zfzx.fwsjcj.modules.taskmanage.taskfrom.entity.FwFormEntity;
import com.css.zfzx.fwsjcj.modules.taskmanage.taskfrom.service.*;
import com.css.zfzx.fwsjcj.modules.user.entity.FwUserEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Consumer;

@Service
public class XCReportServiceImpl implements XCReportService {
    //主表表单service
    @Autowired
    FwStructureFormService fwStructureFormService;
    //砖混结构类型service
    @Autowired
    FwBrickStructureService fwBrickStructureService;
    //砖木结构类型service
    @Autowired
    FwBrickwoodStructureService fwBrickwoodStructureService;
    //土木结构service
    @Autowired
    FwBuildingStructureService fwBuildingStructureService;
    //工业厂房结构service
    @Autowired
    FwFactoryStructureService fwFactoryStructureService;
    //高层结构service
    @Autowired
    FwHighStructureService fwHighStructureService;
    //多层钢筋混凝土service
    @Autowired
    FwMulConcreteStructureService fwMulConcreteStructureService;
    //石结构service
    @Autowired
    FwStoneStructureService fwStoneStructureService;
    //空旷结构service
    @Autowired
    FwWideStructureService fwWideStructureService;
    @Autowired
    //木结构service
    FwWoodStructureService fwWoodStructureService;
    //其他结构service
    @Autowired
    FwOtherStructureService fwOtherStructureService;
    @Autowired
    TaskService taskService;
    @Autowired
    FwGroupUserService fwGroupUserService;
    //城镇住宅
    @Autowired
    CityTaskFormService cityTaskFormService;
    //城镇非住宅
    @Autowired
    NoCityTaskFromService noCityTaskFromService;
    //农村住宅
    @Autowired
    VillageHouseFormService villageHouseFormService;
    //农村公共建筑
    @Autowired
    VillagePubHouseFormService villagePubHouseFormService;
    @Autowired
    TaskFromService taskFromService;
    @Autowired
    private ConfigBeanValue configBeanValue;
    @Autowired
    FwGroupService fwGroupService;
    @Autowired
    TaskQueryRepsitory taskQueryRepsitory;
    private BigDecimal picSize = BigDecimal.valueOf(5);
    @Override
    public void exportReport(String province, String city,String area,String taskName,String timeStamp, HttpServletRequest request, HttpServletResponse response) {
        Map<String, Object> map = new HashMap<>();
        Calendar instance = Calendar.getInstance();
        //获取当前时间的年、月、日
        int year = instance.get(Calendar.YEAR);
        //月份是从0开始的，而现实生活是从一月份开始的，所以要+1
        int month = instance.get(Calendar.MONTH) + 1;
        int day = instance.get(Calendar.DATE);
        String userId = PlatformSessionUtils.getUserId();
        //String userId = "e8efd96e529e4e30bdffb7ff8ab2a58f";
        UserEntity user = PlatformAPI.getOrgAPI().getUserAPI().getUser(userId);
        //查询出详查的数据
        List<FwStructureFormEntity> formList = fwStructureFormService.getFormList(province, city,area,taskName, Constant.SP_YES);
        if (!StringUtils.isEmpty(formList) && formList.size() > 0) {
            //包含的区
            List<String> listArea = new ArrayList<>();
            //时间list
            List<Date> listDate = new ArrayList<>();
            //任务list
            List<String> listTaskId = new ArrayList<>();
            //任务面积List
            List<String> listTaskArea = new ArrayList<>();
            //组长Id
            List<String> listLeaderId = new ArrayList<>();
            //小组ID
            List<String> listGroupId = new ArrayList<>();
            //详查建筑物名称
            List<String> listBuildingName = new ArrayList<>();
            //附件Id
            List<String> listFileId = new ArrayList<>();
            //纬度list
            List<Float> latitude = new ArrayList<>();
            //经度list
            List<Float> longitude = new ArrayList<>();
            //砖混建筑面积之和
            float brickStructureArea = 0.00f;
            //砖混建筑数量之和
            int brickStructureNum = 0;
            //砖木建筑面积之和
            float brickwoodStructureArea = 0.00f;
            //砖木建筑数量之和
            int brickwoodStructureNum = 0;
            //土木结构面积之和
            float buildingStructureArea = 0.00f;
            //土木结构建筑数量之和
            int buildingStructureNum = 0;
            //工厂结构面积之和
            float factoryStructureArea = 0.00f;
            //工厂结构建筑数量之和
            int factoryStructureNum = 0;
            //高层建筑结构面积之和
            float highStructureArea = 0.00f;
            //高层建筑结构建筑数量之和
            int highStructureNum = 0;
            //多层钢筋混凝土面积之和
            float mulConcreteStructureArea = 0.00f;
            //多层钢筋混凝土建筑数量之和
            int mulConcreteStructureNum = 0;
            //石结构面积之和
            float stoneStructureArea = 0.00f;
            //石结构建筑数量之和
            int stoneStructureNum = 0;
            //空旷结构面积之和
            float wideStructureArea = 0.00f;
            //空旷结构建筑数量之和
            int wideStructureNum = 0;
            //木结构面积之和
            float woodStructureArea = 0.00f;
            //木结构建筑数量 之和
            int woodStructureNum = 0;
            //其他结构面积之和
            float otherStructureArea = 0.00f;
            //其他结构建筑数量 之和
            int otherStructureNum = 0;
            // 城镇住宅、城镇非住宅的砖混栋数
            long cityTaskBrickCount = 0L;
            long noCityTaskBrickCount = 0L;
            // 城镇住宅、城镇非住宅的砖混面积
            long cityTaskBrickArea = 0L;
            long noCityTaskBrickArea = 0L;
            // 城镇住宅、城镇非住宅的底层混凝土柱-上部砖混栋数
            long cityTaskTopBrickCount = 0L;
            long noCityTaskTopBrickCount = 0L;
            // 城镇住宅、城镇非住宅的底层混凝土柱-上部砖混面积
            long cityTaskTopBrickArea = 0L;
            long noCityTaskTopBrickArea = 0L;
            // 城镇住宅、城镇非住宅的钢筋混凝土栋数
            long cityTaskReinforcedConcreteCount = 0L;
            long noCityTaskReinforcedConcreteCount = 0L;
            // 城镇住宅、城镇非住宅的钢筋混凝土面积
            long cityTaskReinforcedConcreteArea = 0L;
            long noCityTaskReinforcedConcreteArea = 0L;
            // 城镇住宅、城镇非住宅的砖木栋数
            long cityTaskBrickWoodCount = 0L;
            long noCityTaskBrickWoodCount = 0L;
            // 城镇住宅、城镇非住宅的砖木面积
            long cityTaskBrickWoodArea = 0L;
            long noCityTaskBrickWoodArea = 0L;
            // 城镇住宅、城镇非住宅的钢结构栋数
            long cityTaskSteelStructureCount = 0L;
            long noCityTaskSteelStructureCount = 0L;
            // 城镇住宅、城镇非住宅的钢结构面积
            long cityTaskSteelStructureArea = 0L;
            long noCityTaskSteelStructureArea = 0L;
            // 城镇住宅、城镇非住宅的木结构栋数
            long cityTaskWoodStructureCount = 0L;
            long noCityTaskWoodStructureCount = 0L;
            // 城镇住宅、城镇非住宅的木结构面积
            long cityTaskWoodStructureArea = 0L;
            long noCityTaskWoodStructureArea = 0L;
            // 城镇住宅、城镇非住宅的木结构栋数
            long cityTaskOtherCount = 0L;
            long noCityTaskOtherCount = 0L;
            // 城镇住宅、城镇非住宅的木结构面积
            long cityTaskOtherArea = 0L;
            long noCityTaskOtherArea = 0L;
            // 农村住宅、农村公共建筑的砖(砌块)混栋数
            long villageHouseBrickCount = 0L;
            long villagePubHouseBrickCount = 0L;
            // 农村住宅、农村公共建筑的砖(砌块)混面积
            long villageHouseBrickArea = 0L;
            long villagePubHouseBrickArea = 0L;
            // 农村住宅、农村公共建筑的低层框架栋数
            long villageHouseLowerFrameCount = 0L;
            long villagePubHouseLowerFrameCount = 0L;
            // 农村住宅、农村公共建筑的低层框架面积
            long villageHouseLowerFrameArea = 0L;
            long villagePubHouseLowerFrameArea = 0L;
            // 农村住宅、农村公共建筑的轻钢(钢)装配式栋数
            long villageHouseSteelAssemblyCount = 0L;
            long villagePubHouseSteelAssemblyCount = 0L;
            // 农村住宅、农村公共建筑的轻钢(钢)装配式面积
            long villageHouseSteelAssemblyArea = 0L;
            long villagePubHouseSteelAssemblyArea = 0L;
            // 农村住宅、农村公共建筑的混凝土装配式栋数
            long villageHouseConcreteAssemblyCount = 0L;
            long villagePubHouseConcreteAssemblyCount = 0L;
            // 农村住宅、农村公共建筑的混凝土装配式面积
            long villageHouseConcreteAssemblyArea = 0L;
            long villagePubHouseConcreteAssemblyArea = 0L;
            // 农村住宅、农村公共建筑的砖木栋数
            long villageHouseBrickWoodCount = 0L;
            long villagePubHouseBrickWoodCount = 0L;
            // 农村住宅、农村公共建筑的砖木面积
            long villageHouseBrickWoodArea = 0L;
            long villagePubHouseBrickWoodArea = 0L;
            // 农村住宅、农村公共建筑的砖木栋数
            long villageHouseCivilWoodCount = 0L;
            long villagePubHouseCivilWoodCount = 0L;
            // 农村住宅、农村公共建筑的砖木面积
            long villageHouseCivilWoodArea = 0L;
            long villagePubHouseCivilWoodArea = 0L;
            // 农村住宅、农村公共建筑的石木栋数
            long villageHouseStoneWoodCount = 0L;
            long villagePubHouseStoneWoodCount = 0L;
            // 农村住宅、农村公共建筑的石木面积
            long villageHouseStoneWoodArea = 0L;
            long villagePubHouseStoneWoodArea = 0L;
            // 农村住宅、农村公共建筑的木结构栋数
            long villageHouseWoodStructureCount = 0L;
            long villagePubHouseWoodStructureCount = 0L;
            // 农村住宅、农村公共建筑的木结构面积
            long villageHouseWoodStructureArea = 0L;
            long villagePubHouseWoodStructureArea = 0L;
            // 农村住宅、农村公共建筑的窑洞栋数
            long villageHouseCaveDwellingCount = 0L;
            long villagePubHouseCaveDwellingCount = 0L;
            // 农村住宅、农村公共建筑的窑洞面积
            long villageHouseCaveDwellingArea = 0L;
            long villagePubHouseCaveDwellingArea = 0L;
            // 农村住宅、农村公共建筑的混杂结构（砖/砌块/土/石）栋数
            long villageHouseMixedStructureCount = 0L;
            long villagePubHouseMixedStructureCount = 0L;
            // 农村住宅、农村公共建筑的混杂结构（砖/砌块/土/石）面积
            long villageHouseMixedStructureArea = 0L;
            long villagePubHouseMixedStructureArea = 0L;
            // 农村住宅、农村公共建筑的其它栋数
            long villageHouseOtherCount = 0L;
            long villagePubHouseOtherCount = 0L;
            // 农村住宅、农村公共建筑的其它面积
            long villageHouseOtherArea = 0L;
            long villagePubHouseOtherArea = 0L;
            for (FwStructureFormEntity fwStructureFormEntity : formList) {
                //字表ID
                String structureId = fwStructureFormEntity.getStructureId();
                //表单类型
                String structureType = fwStructureFormEntity.getStructureType();
                //砖混结构
                FwBrickStructureEntity fwBrickStructureEntity = null;
                //砖木结构
                FwBrickwoodStructureEntity fwBrickwoodStructureEntity = null;
                //土木结构
                FwBuildingStructureEntity fwBuildingStructureServiceById = null;
                //工厂结构
                FwFactoryStructureEntity fwFactoryStructureEntity = null;
                //高层建筑
                FwHighStructureEntity fwHighStructureEntity = null;
                //多层钢筋混凝土
                FwMulConcreteStructureEntity fwMulConcreteStructureEntity = null;
                //石结构
                FwStoneStructureEntity fwStoneStructureEntity = null;
                //空旷结构
                FwWideStructureEntity fwWideStructureEntity = null;
                //木结构
                FwWoodStructureEntity fwWoodStructureEntity = null;
                //其他结构
                FwOtherStructureEntity fwOtherStructureEntity = null;
                //获取区域面积
                String belongtoArea = "";
                //砖混结构
                if (Constant.BRICK_STRUCTURE.equals(structureType)) {
                    fwBrickStructureEntity = fwBrickStructureService.findById(structureId);
                    Date createTime = fwBrickStructureEntity.getCreateTime();
                    String taskId = fwBrickStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwBrickStructureEntity.getBuildingName());
                    listArea.add(fwBrickStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwBrickStructureEntity.getDetailFile())) {
                        listFileId.add(fwBrickStructureEntity.getDetailFile());
                    }
                    brickStructureNum++;
                    if (!StringUtils.isEmpty(fwBrickStructureEntity.getBuildingArea())) {
                        brickStructureArea += fwBrickStructureEntity.getBuildingArea();
                    }
                    try{
                        if (!StringUtils.isEmpty(fwBrickStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwBrickStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwBrickStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwBrickStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //砖木结构
                if (Constant.BRICKWOOD_STRUCTURE.equals(structureType)) {
                    fwBrickwoodStructureEntity = fwBrickwoodStructureService.findById(structureId);
                    Date createTime = fwBrickwoodStructureEntity.getCreateTime();
                    String taskId = fwBrickwoodStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwBrickwoodStructureEntity.getBuildingName());
                    listArea.add(fwBrickwoodStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwBrickwoodStructureEntity.getDetailFile())) {
                        listFileId.add(fwBrickwoodStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwBrickwoodStructureEntity.getBuildingArea())) {
                        brickwoodStructureArea += fwBrickwoodStructureEntity.getBuildingArea();
                    }
                    brickwoodStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwBrickwoodStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwBrickwoodStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwBrickwoodStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwBrickwoodStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //土木结构
                if (Constant.BUILDING_STRUCTURE.equals(structureType)) {
                    fwBuildingStructureServiceById = fwBuildingStructureService.findById(structureId);
                    Date createTime = fwBuildingStructureServiceById.getCreateTime();
                    String taskId = fwBuildingStructureServiceById.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwBuildingStructureServiceById.getBuildingName());
                    listArea.add(fwBuildingStructureServiceById.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwBuildingStructureServiceById.getDetailFile())) {
                        listFileId.add(fwBuildingStructureServiceById.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwBuildingStructureServiceById.getBuildingArea())) {
                        buildingStructureArea += fwBuildingStructureServiceById.getBuildingArea();
                    }
                    buildingStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwBuildingStructureServiceById.getLongitude())) {
                            longitude.add(Float.parseFloat(fwBuildingStructureServiceById.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwBuildingStructureServiceById.getLatitude())) {
                            latitude.add(Float.parseFloat(fwBuildingStructureServiceById.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //工厂结构
                if (Constant.FACTORY_STRUCTURE.equals(structureType)) {
                    fwFactoryStructureEntity = fwFactoryStructureService.findById(structureId);
                    Date createTime = fwFactoryStructureEntity.getCreateTime();
                    String taskId = fwFactoryStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwFactoryStructureEntity.getBuildingName());
                    listArea.add(fwFactoryStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwFactoryStructureEntity.getDetailFile())) {
                        listFileId.add(fwFactoryStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwFactoryStructureEntity.getBuildingArea())) {
                        factoryStructureArea += fwFactoryStructureEntity.getBuildingArea();
                    }
                    factoryStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwFactoryStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwFactoryStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwFactoryStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwFactoryStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //高层结构
                if (Constant.HIGH_STRUCTURE.equals(structureType)) {
                    fwHighStructureEntity = fwHighStructureService.findById(structureId);
                    Date createTime = fwHighStructureEntity.getCreateTime();
                    String taskId = fwHighStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwHighStructureEntity.getBuildingName());
                    listArea.add(fwHighStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwHighStructureEntity.getDetailFile())) {
                        listFileId.add(fwHighStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwHighStructureEntity.getBuildingArea())) {
                        highStructureArea += fwHighStructureEntity.getBuildingArea();
                    }
                    highStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwHighStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwHighStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwHighStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwHighStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //多层钢筋混凝土
                if (Constant.MUL_CONCRETE_STRUCTURE.equals(structureType)) {
                    fwMulConcreteStructureEntity = fwMulConcreteStructureService.findById(structureId);
                    Date createTime = fwMulConcreteStructureEntity.getCreateTime();
                    String taskId = fwMulConcreteStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwMulConcreteStructureEntity.getBuildingName());
                    listArea.add(fwMulConcreteStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwMulConcreteStructureEntity.getDetailFile())) {
                        listFileId.add(fwMulConcreteStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwMulConcreteStructureEntity.getBuildingArea())) {
                        mulConcreteStructureArea += fwMulConcreteStructureEntity.getBuildingArea();
                    }
                    mulConcreteStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwMulConcreteStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwMulConcreteStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwMulConcreteStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwMulConcreteStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //石结构
                if (Constant.STONE_STRUCTURE.equals(structureType)) {
                    fwStoneStructureEntity = fwStoneStructureService.findById(structureId);
                    Date createTime = fwStoneStructureEntity.getCreateTime();
                    String taskId = fwStoneStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwStoneStructureEntity.getBuildingName());
                    listArea.add(fwStoneStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwStoneStructureEntity.getDetailFile())) {
                        listFileId.add(fwStoneStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwStoneStructureEntity.getBuildingArea())) {
                        stoneStructureArea += fwStoneStructureEntity.getBuildingArea();
                    }
                    stoneStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwStoneStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwStoneStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwStoneStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwStoneStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //空旷结构
                if (Constant.WIDE_STRUCTURE.equals(structureType)) {
                    fwWideStructureEntity = fwWideStructureService.findById(structureId);
                    Date createTime = fwWideStructureEntity.getCreateTime();
                    String taskId = fwWideStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwWideStructureEntity.getBuildingName());
                    listArea.add(fwWideStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwWideStructureEntity.getDetailFile())) {
                        listFileId.add(fwWideStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwWideStructureEntity.getBuildingArea())) {
                        wideStructureArea += fwWideStructureEntity.getBuildingArea();
                    }
                    wideStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwWideStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwWideStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwWideStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwWideStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //木结构
                if (Constant.WOOD_STRUCTURE.equals(structureType)) {
                    fwWoodStructureEntity = fwWoodStructureService.findById(structureId);
                    Date createTime = fwWoodStructureEntity.getCreateTime();
                    String taskId = fwWoodStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwWoodStructureEntity.getBuildingName());
                    listArea.add(fwWoodStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwWoodStructureEntity.getDetailFile())) {
                        listFileId.add(fwWoodStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwWoodStructureEntity.getBuildingArea())) {
                        woodStructureArea += fwWoodStructureEntity.getBuildingArea();
                    }
                    woodStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwWoodStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwWoodStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwWoodStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwWoodStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
                //其他结构
                if (Constant.OTHER_STRUCTURE.equals(structureType)) {
                    fwOtherStructureEntity = fwOtherStructureService.findById(structureId);
                    Date createTime = fwOtherStructureEntity.getCreateTime();
                    String taskId = fwOtherStructureEntity.getTaskId();
                    listDate.add(createTime);
                    listTaskId.add(taskId);
                    listBuildingName.add(fwOtherStructureEntity.getBuildingName());
                    listArea.add(fwOtherStructureEntity.getBelongtoArea());
                    if (!StringUtils.isEmpty(fwOtherStructureEntity.getDetailFile())) {
                        listFileId.add(fwOtherStructureEntity.getDetailFile());
                    }
                    if (!StringUtils.isEmpty(fwOtherStructureEntity.getBuildingArea())) {
                        otherStructureArea += fwOtherStructureEntity.getBuildingArea();
                    }
                    otherStructureNum++;
                    try{
                        if (!StringUtils.isEmpty(fwOtherStructureEntity.getLongitude())) {
                            longitude.add(Float.parseFloat(fwOtherStructureEntity.getLongitude()));
                        }
                        if (!StringUtils.isEmpty(fwOtherStructureEntity.getLatitude())) {
                            latitude.add(Float.parseFloat(fwOtherStructureEntity.getLatitude()));
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
            //详查总栋数
            int countNum = brickStructureNum + buildingStructureNum + factoryStructureNum + highStructureNum + mulConcreteStructureNum + stoneStructureNum + wideStructureNum + woodStructureNum;
            //详查总面积
            float countArea = brickStructureArea + buildingStructureArea + factoryStructureArea + highStructureArea + mulConcreteStructureArea + stoneStructureArea + wideStructureArea + woodStructureArea;
            //附件大小总数  按个数乘以文件平均大小 5M 进行计算
            Long size = 0L;
            if (!StringUtils.isEmpty(listFileId) && listFileId.size() > 0) {
                size = Long.valueOf(5*listFileId.size()/1024);
            }
            //砖混总数占比
            StringBuilder brickStructureNumProportion = null;
            //砖混总数必须大于0
            if (brickStructureNum > 0) {
                double num = (brickStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                brickStructureNumProportion = new StringBuilder();
                brickStructureNumProportion.append(format + "%");
            }
            //砖混面积总数占比
            StringBuilder brickStructureAreaProportion = null;
            //砖混面积总数必须大于0
            if (brickStructureNum > 0f) {
                float num = (brickStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                brickStructureAreaProportion = new StringBuilder();
                brickStructureAreaProportion.append(format + "%");
            }
            //砖木总数占比
            StringBuilder brickwoodStructureNumProportion = null;
            //砖木总数必须大于0
            if (brickwoodStructureNum > 0) {
                double num = (brickwoodStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                brickwoodStructureNumProportion = new StringBuilder();
                brickwoodStructureNumProportion.append(format + "%");
            }
            //砖木面积总数占比
            StringBuilder brickwoodStructureAreaProportion = null;
            //砖木面积总数必须大于0
            if (brickwoodStructureArea > 0f) {
                float num = (brickwoodStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                brickwoodStructureAreaProportion = new StringBuilder();
                brickwoodStructureAreaProportion.append(format + "%");
            }
            //土木结构总数占比
            StringBuilder buildingStructureNumProportion = null;
            //土木结构总数必须大于0
            if (buildingStructureNum > 0) {
                double num = (buildingStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                buildingStructureNumProportion = new StringBuilder();
                buildingStructureNumProportion.append(format + "%");
            }
            //土木结构面积总数占比
            StringBuilder buildingStructureAreaProportion = null;
            //土木结构面积总数必须大于0
            if (buildingStructureArea > 0f) {
                float num = (buildingStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                buildingStructureAreaProportion = new StringBuilder();
                buildingStructureAreaProportion.append(format + "%");
            }
            //多层钢筋混凝土结构总数占比
            StringBuilder mulConcreteStructureNumProportion = null;
            //多层钢筋混凝总数必须大于0
            if (mulConcreteStructureNum > 0) {
                double num = (mulConcreteStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                mulConcreteStructureNumProportion = new StringBuilder();
                mulConcreteStructureNumProportion.append(format + "%");
            }
            //多层钢筋混凝土面积总数占比
            StringBuilder mulConcreteStructureAreaProportion = null;
            //多层钢筋混凝土面积总数必须大于0
            if (mulConcreteStructureArea > 0f) {
                float num = (mulConcreteStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                mulConcreteStructureAreaProportion = new StringBuilder();
                mulConcreteStructureAreaProportion.append(format + "%");
            }
            //高层结构总数占比
            StringBuilder highStructureNumProportion = null;
            //高层总数必须大于0
            if (highStructureNum > 0) {
                double num = (highStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                highStructureNumProportion = new StringBuilder();
                highStructureNumProportion.append(format + "%");
            }
            //高层结构面积总数占比
            StringBuilder highStructureAreaProportion = null;
            //高层结构面积总数必须大于0
            if (highStructureArea > 0f) {
                float num = (highStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                highStructureAreaProportion = new StringBuilder();
                highStructureAreaProportion.append(format + "%");
            }
            //工厂结构总数占比
            StringBuilder factoryStructureNumProportion = null;
            //工厂结构总数必须大于0
            if (factoryStructureNum > 0) {
                double num = (factoryStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                factoryStructureNumProportion = new StringBuilder();
                factoryStructureNumProportion.append(format + "%");
            }
            //工厂结构面积总数占比
            StringBuilder factoryStructureAreaProportion = null;
            //工厂结构面积总数必须大于0
            if (factoryStructureArea > 0f) {
                float num = (factoryStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                factoryStructureAreaProportion = new StringBuilder();
                factoryStructureAreaProportion.append(format + "%");
            }
            //石结构总数占比
            StringBuilder stoneStructureNumProportion = null;
            //石结构总数必须大于0
            if (stoneStructureNum > 0) {
                double num = (stoneStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                stoneStructureNumProportion = new StringBuilder();
                stoneStructureNumProportion.append(format + "%");
            }
            //石结构面积总数占比
            StringBuilder stoneStructureAreaProportion = null;
            //石结构面积总数必须大于0
            if (stoneStructureArea > 0f) {
                float num = (stoneStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                stoneStructureAreaProportion = new StringBuilder();
                stoneStructureAreaProportion.append(format + "%");
            }
            //空旷结构总数占比
            StringBuilder wideStructureNumProportion = null;
            //空旷结构总数必须大于0
            if (wideStructureNum > 0) {
                double num = (wideStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                wideStructureNumProportion = new StringBuilder();
                wideStructureNumProportion.append(format + "%");
            }
            //空旷结构面积总数占比
            StringBuilder wideStructureAreaProportion = null;
            //空旷结构面积总数必须大于0
            if (wideStructureArea > 0f) {
                float num = (wideStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                wideStructureAreaProportion = new StringBuilder();
                wideStructureAreaProportion.append(format + "%");
            }
            //木结构总数占比
            StringBuilder woodStructureNumProportion = null;
            //木结构总数必须大于0
            if (woodStructureNum > 0) {
                double num = (woodStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                woodStructureNumProportion = new StringBuilder();
                woodStructureNumProportion.append(format + "%");
            }
            //木结构面积总数占比
            StringBuilder woodStructureAreaProportion = null;
            //木结构面积总数必须大于0
            if (woodStructureArea > 0f) {
                float num = (woodStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                woodStructureAreaProportion = new StringBuilder();
                woodStructureAreaProportion.append(format + "%");
            }
            //其他结构总数占比
            StringBuilder otherStructureNumProportion = null;
            //其他结构总数必须大于0
            if (otherStructureNum > 0) {
                double num = (otherStructureNum / (double) countNum) * 100;
                String format = String.format("%.2f", num);
                otherStructureNumProportion = new StringBuilder();
                otherStructureNumProportion.append(format + "%");
            }
            //其他结构面积总数占比
            StringBuilder otherStructureAreaProportion = null;
            //其他结构面积总数必须大于0
            if (otherStructureArea > 0f) {
                float num = (otherStructureArea / countArea) * 100;
                String format = String.format("%.2f", num);
                otherStructureAreaProportion = new StringBuilder();
                otherStructureAreaProportion.append(format + "%");
            }

            //任务包含的区去重
            List<String> areaList = new ArrayList<>(new TreeSet<>(listArea));
            //获取最小时间
            String minTime = DateUtils.getMinTime(listDate);
            //获取最大时间
            String maxTime = DateUtils.getMaxTime(listDate);
            //获取相差天数
            long countDay = DateUtils.getDay(minTime, maxTime) + 1;
            //任务id去重
            List<String> onlyTaskId = new ArrayList<>(new TreeSet<>(listTaskId));
            //一个任务对应一个小组所以它们是等值的
            int groupCount = onlyTaskId.size();
            //根据任务Id查询任务
            List<FwTaskEntity> formEntities = taskService.findByIds(onlyTaskId);
            //取出领导ID
            formEntities.forEach(fwTaskEntity -> {
                listLeaderId.add(fwTaskEntity.getGroupLeaderId());
                listGroupId.add(fwTaskEntity.getGroupId());
                listTaskArea.add(fwTaskEntity.getTaskArea());
            });
            //将组长id去重
            List<String> onlyLeaderId = new ArrayList<>(new TreeSet<>(listLeaderId));
            //小组id去重
            List<String> onlyGroupId = new ArrayList<>(new TreeSet<>(listGroupId));
            List<FwGroupEntity> groupList = fwGroupService.findListById(onlyGroupId);
            //小组成员Id
            List<String> listGroupUserId = new ArrayList<>();
            //获取小组成员
            for (String groupId : onlyGroupId) {
                List<FwGroupUserEntity> groupUser = fwGroupUserService.findByGroupId(groupId);
                for (FwGroupUserEntity fwGroupUserEntity : groupUser) {
                    listGroupUserId.add(fwGroupUserEntity.getUserId());
                }
            }
            //利用hashSet的去重特性
            HashSet<String> hashSet = new HashSet<>();
            hashSet.addAll(listGroupUserId);
            //清空原有的元素数组，放入去重后的元素
            listGroupUserId.clear();
            listGroupUserId.addAll(hashSet);
            //移除组员id中包含组长的id
            listGroupUserId.removeAll(onlyLeaderId);
            //再将组长Id和组员Id并集
            listGroupUserId.addAll(onlyLeaderId);
            //获取最小纬度
            Float minLatitude=0.00f;
            //获取最大纬度
            Float maxLatitude=0.00f;
            //获取最小经度
            Float minLongitude=0.00f;
            //获取最大经度
            Float maxLongitude=0.00f;
            if(!StringUtils.isEmpty(latitude)&&latitude.size()>0&&!StringUtils.isEmpty(longitude)&&longitude.size()>0){
                //获取最小纬度
                minLatitude = Collections.min(latitude);
                //获取最大纬度
                maxLatitude = Collections.max(latitude);
                //获取最小经度
                minLongitude = Collections.min(longitude);
                //获取最大经度
                maxLongitude = Collections.max(longitude);
            }
            //任务面积
            float taskAreaCount = 0.00f;
            Integer provinceCount = 0;
            Integer cityCount = 0;
            Integer areaCount = 0;
            if (listTaskArea.size() > 0) {
                for (String taskArea : listTaskArea) {
                    if (!StringUtils.isEmpty(taskArea)) {
                        float parseFloat = Float.parseFloat(taskArea);
                        taskAreaCount += parseFloat;
                    }
                }
            }
            //new——通过 详查任务的任务区域 查询在该区域的 普查数据  formEntities  taskFromService.findByAddress
            if (!PlatformObjectUtils.isEmpty(formEntities) && formEntities.size() > 0) {
                //查询条件
                List<AnalysisQueryVo> analysisQueryVoList= new ArrayList<>();
                if (StringUtils.isEmpty(taskName)){
                    AnalysisQueryVo analysisQueryVo = new AnalysisQueryVo();
                    if(StringUtils.isEmpty(taskName)&&StringUtils.isEmpty(province)){
                        String taskRange = "全国";
                        map.put("taskRange",taskRange);
                    }
                    analysisQueryVo.setBelongtoProvince(province);
                    analysisQueryVo.setBelongtoCity(city);
                    analysisQueryVo.setBelongtoArea(area);
                    analysisQueryVo.setSpType(Constant.SP_YES);
                    Map<String, Integer> belongtoCount = fwStructureFormService.getBelongtoCount(province, city,area);
                    provinceCount = belongtoCount.get("provinceCount");
                    cityCount = belongtoCount.get("cityCount");
                    areaCount = belongtoCount.get("areaCount");
                    analysisQueryVoList.add(analysisQueryVo);
                }else {
                    //taskName不为空
                    for (FwTaskEntity entity:formEntities) {
                        AnalysisQueryVo analysisQueryVo = new AnalysisQueryVo();
                        String[] strings = DivisionAnalysUtil.convertDetailAddressToPCD(entity.getDivision());
                        analysisQueryVo.setBelongtoProvince(strings[0]);
                        province = strings[0];
                        city = "";
                        area = "";
                        if (strings.length>1){
                            analysisQueryVo.setBelongtoCity(strings[1]);
                            city = strings[1];
                        }
                        if (strings.length>2){
                            analysisQueryVo.setBelongtoArea(strings[2]);
                            area = strings[2];
                        }
                        analysisQueryVo.setSpType(Constant.SP_YES);
                        analysisQueryVoList.add(analysisQueryVo);
                    }
                }
                for (AnalysisQueryVo analysisQueryVo:analysisQueryVoList) {
                    //普查的结构类型砖混
                    analysisQueryVo.setStructureType("砖混");
                    // 城镇住宅、城镇非住宅数量
                    cityTaskBrickCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskBrickCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅 面积
                    cityTaskBrickArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskBrickArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型底层混凝土柱-上部砖混
                    analysisQueryVo.setStructureType("底层混凝土柱-上部砖混");
                    // 城镇住宅、城镇非住宅栋数
                    cityTaskTopBrickCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskTopBrickCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅面积
                    cityTaskTopBrickArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskTopBrickArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型钢筋混凝土
                    analysisQueryVo.setStructureType("钢筋混凝土");
                    // 城镇住宅、城镇非住宅栋数
                    cityTaskReinforcedConcreteCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskReinforcedConcreteCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅面积
                    cityTaskReinforcedConcreteArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskReinforcedConcreteArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型钢砖木
                    analysisQueryVo.setStructureType("砖木");
                    // 城镇住宅、城镇非住宅栋数
                    cityTaskBrickWoodCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskBrickWoodCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅面积
                    cityTaskBrickWoodArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskBrickWoodArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型钢结构
                    analysisQueryVo.setStructureType("钢结构");
                    // 城镇住宅、城镇非住宅栋数
                    cityTaskSteelStructureCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskSteelStructureCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅面积
                    cityTaskSteelStructureArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskSteelStructureArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型木结构
                    analysisQueryVo.setStructureType("木结构");
                    // 城镇住宅、城镇非住宅栋数
                    cityTaskWoodStructureCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskWoodStructureCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅面积
                    cityTaskWoodStructureArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskWoodStructureArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型木结构
                    analysisQueryVo.setStructureType("其它");
                    // 城镇住宅、城镇非住宅栋数
                    cityTaskOtherCount += cityTaskFormService.count(analysisQueryVo);
                    noCityTaskOtherCount += noCityTaskFromService.count(analysisQueryVo);
                    // 城镇住宅、城镇非住宅面积
                    cityTaskOtherArea += cityTaskFormService.areaCount(analysisQueryVo);
                    noCityTaskOtherArea += noCityTaskFromService.areaCount(analysisQueryVo);

                    //普查的结构类型砖(砌块)混
                    analysisQueryVo.setStructureType("砖(砌块)混");
                    //农村住房、农村公共建筑 数量
                    villageHouseBrickCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseBrickCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseBrickArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseBrickArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型低层框架
                    analysisQueryVo.setStructureType("低层框架");
                    //农村住房、农村公共建筑 数量
                    villageHouseLowerFrameCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseLowerFrameCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseLowerFrameArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseLowerFrameArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型轻钢(钢)装配式
                    analysisQueryVo.setStructureType("轻钢(钢)装配式");
                    //农村住房、农村公共建筑 数量
                    villageHouseSteelAssemblyCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseSteelAssemblyCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseSteelAssemblyArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseSteelAssemblyArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型混凝土装配式
                    analysisQueryVo.setStructureType("混凝土装配式");
                    //农村住房、农村公共建筑 数量
                    villageHouseConcreteAssemblyCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseConcreteAssemblyCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseConcreteAssemblyArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseConcreteAssemblyArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型砖木
                    analysisQueryVo.setStructureType("砖木");
                    //农村住房、农村公共建筑 数量
                    villageHouseBrickWoodCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseBrickWoodCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseBrickWoodArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseBrickWoodArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型土木
                    analysisQueryVo.setStructureType("土木");
                    //农村住房、农村公共建筑 数量
                    villageHouseCivilWoodCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseCivilWoodCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseCivilWoodArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseCivilWoodArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型石木
                    analysisQueryVo.setStructureType("石木");
                    //农村住房、农村公共建筑 数量
                    villageHouseStoneWoodCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseStoneWoodCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseStoneWoodArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseStoneWoodArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型木结构
                    analysisQueryVo.setStructureType("木结构");
                    //农村住房、农村公共建筑 数量
                    villageHouseWoodStructureCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseWoodStructureCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseWoodStructureArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseWoodStructureArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型木结构
                    analysisQueryVo.setStructureType("窑洞");
                    //农村住房、农村公共建筑 数量
                    villageHouseCaveDwellingCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseCaveDwellingCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseCaveDwellingArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseCaveDwellingArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型混杂结构（砖/砌块/土/石）
                    analysisQueryVo.setStructureType("混杂结构（砖/砌块/土/石）");
                    //农村住房、农村公共建筑 数量
                    villageHouseMixedStructureCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseMixedStructureCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseMixedStructureArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseMixedStructureArea += villagePubHouseFormService.areaCount(analysisQueryVo);

                    //普查的结构类型其它
                    analysisQueryVo.setStructureType("其它");
                    //农村住房、农村公共建筑 数量
                    villageHouseOtherCount += villageHouseFormService.count(analysisQueryVo);
                    villagePubHouseOtherCount += villagePubHouseFormService.count(analysisQueryVo);
                    //农村住房、农村公共建筑 面积
                    villageHouseOtherArea += villageHouseFormService.areaCount(analysisQueryVo);
                    villagePubHouseOtherArea += villagePubHouseFormService.areaCount(analysisQueryVo);
                }
            }

            //砖混结构、砖石木结构普查总栋数
            long brickNumXC = cityTaskBrickCount + cityTaskTopBrickCount + noCityTaskBrickCount + noCityTaskTopBrickCount + villageHouseBrickCount + villagePubHouseBrickCount + villageHouseBrickWoodCount + villagePubHouseBrickWoodCount + villageHouseStoneWoodCount + villagePubHouseStoneWoodCount;
            //砖混结构、砖石木结构普查总面积
            long brickAreaXC = cityTaskBrickArea + cityTaskTopBrickArea + noCityTaskBrickArea + noCityTaskTopBrickArea + villageHouseBrickArea + villagePubHouseBrickArea + villageHouseBrickWoodArea + villagePubHouseBrickWoodArea + villageHouseStoneWoodArea + villageHouseStoneWoodArea;
            //多层钢筋混凝土结构普查总栋数
            long mulConcreteStructureNumXC = cityTaskReinforcedConcreteCount + noCityTaskReinforcedConcreteCount + villageHouseLowerFrameCount + villagePubHouseLowerFrameCount;
            //多层钢筋混凝土结构普查总面积
            long mulConcreteStructureAreaXC = cityTaskReinforcedConcreteArea + noCityTaskReinforcedConcreteArea + villageHouseLowerFrameArea + villagePubHouseLowerFrameArea;
            //高层结构总栋数
            long highStructureNumXC = cityTaskReinforcedConcreteCount;
            //高层结构总面积
            long highStructureAreaXC = cityTaskReinforcedConcreteArea;
            //工厂结构结构总栋数
            long factoryStructureNumXC = noCityTaskSteelStructureCount + cityTaskSteelStructureCount + villageHouseConcreteAssemblyCount + villagePubHouseConcreteAssemblyCount + villageHouseSteelAssemblyCount + villagePubHouseConcreteAssemblyCount;
            //工厂结构结构总面积
            long factoryStructureAreaXC = noCityTaskSteelStructureArea + cityTaskSteelStructureArea + villageHouseConcreteAssemblyArea + villagePubHouseConcreteAssemblyArea + villageHouseSteelAssemblyArea + villagePubHouseSteelAssemblyArea;
            //空旷结构结构总栋数
            long wideStructureNumXC = noCityTaskSteelStructureCount + cityTaskSteelStructureCount + villageHouseConcreteAssemblyCount + villagePubHouseConcreteAssemblyCount + villageHouseSteelAssemblyCount + villagePubHouseConcreteAssemblyCount;
            //空旷结构结构总面积
            long wideStructureAreaXC = noCityTaskSteelStructureArea + cityTaskSteelStructureArea + villageHouseConcreteAssemblyArea + villagePubHouseConcreteAssemblyArea + villageHouseSteelAssemblyArea + villagePubHouseSteelAssemblyArea;
            //土木结构总栋数
            long buildingStructureNumXC = villageHouseCivilWoodCount + villagePubHouseCivilWoodCount + villageHouseCivilWoodArea + villagePubHouseCivilWoodArea;
            //土木结构总面积
            long buildingStructureAreaXC = villageHouseCivilWoodArea + villagePubHouseCivilWoodArea;
            //木结构总栋数
            long woodStructureNumXC = cityTaskWoodStructureCount + noCityTaskWoodStructureCount + villageHouseWoodStructureCount + villagePubHouseWoodStructureCount;
            //木结构总面积
            long woodStructureAreaXC = cityTaskWoodStructureArea + noCityTaskWoodStructureArea + villageHouseWoodStructureArea + villagePubHouseWoodStructureArea;
            //石结构总栋数
            long stoneStructureNumXC = villageHouseMixedStructureCount + villagePubHouseMixedStructureCount;
            //石结构总面积
            long stoneStructureAreaXC = villageHouseMixedStructureArea + villagePubHouseMixedStructureArea;
            //其他结构总栋数
            long otherStructureNumXC = villageHouseOtherCount + villagePubHouseOtherCount;
            //其他结构总面积
            long otherStructureAreaXC = villageHouseOtherArea + villagePubHouseOtherArea;
            //城镇总栋数
            long cityCountNum = cityTaskBrickCount + noCityTaskBrickCount + cityTaskOtherCount + noCityTaskOtherCount + cityTaskBrickWoodCount + noCityTaskBrickWoodCount + cityTaskReinforcedConcreteCount + noCityTaskReinforcedConcreteCount + cityTaskSteelStructureCount + noCityTaskSteelStructureCount + cityTaskTopBrickCount + noCityTaskTopBrickCount + cityTaskWoodStructureCount + noCityTaskWoodStructureCount;
            //农村总栋数
            long villageCountNum = villageHouseBrickCount + villageHouseBrickWoodCount + villageHouseCaveDwellingCount + villageHouseCivilWoodCount + villageHouseConcreteAssemblyCount + villageHouseLowerFrameCount + villageHouseLowerFrameCount + villageHouseMixedStructureCount + villageHouseOtherCount + villageHouseSteelAssemblyCount + villageHouseStoneWoodCount + villageHouseWoodStructureCount + villagePubHouseBrickCount + villagePubHouseBrickWoodCount + villagePubHouseCaveDwellingCount + villagePubHouseCivilWoodCount + villagePubHouseConcreteAssemblyCount + villagePubHouseLowerFrameCount + villagePubHouseMixedStructureCount + villagePubHouseOtherCount + villagePubHouseSteelAssemblyCount + villagePubHouseStoneWoodCount + villagePubHouseWoodStructureCount;
            //城镇总面积
            long cityCountArea = cityTaskBrickArea + cityTaskBrickWoodArea + cityTaskOtherArea + cityTaskReinforcedConcreteArea + cityTaskSteelStructureArea + cityTaskTopBrickArea + cityTaskWoodStructureArea + noCityTaskBrickArea + noCityTaskBrickWoodArea + noCityTaskOtherArea + noCityTaskReinforcedConcreteArea + noCityTaskSteelStructureArea + noCityTaskTopBrickArea + noCityTaskWoodStructureArea;
            //农村总面积
            long villageCountArea = villageHouseBrickArea + villageHouseBrickWoodArea + villageHouseCaveDwellingArea + villageHouseCivilWoodArea + villageHouseConcreteAssemblyArea + villageHouseLowerFrameArea + villageHouseMixedStructureArea + villageHouseOtherArea + villageHouseSteelAssemblyArea + villageHouseStoneWoodArea + villageHouseWoodStructureArea + villagePubHouseBrickArea + villagePubHouseBrickWoodArea + villagePubHouseCaveDwellingArea + villagePubHouseCivilWoodArea + villagePubHouseConcreteAssemblyArea + villagePubHouseLowerFrameArea + villagePubHouseMixedStructureArea + villagePubHouseOtherArea + villagePubHouseSteelAssemblyArea + villagePubHouseStoneWoodArea + villagePubHouseWoodStructureArea;
            //砖混栋数抽样率，详查/普查
            StringBuilder brickNumProportion = null;
            if (brickNumXC > 0L) {
                double num = (brickStructureNum / (double) brickNumXC) * 100;
                if (num > 100){
                    brickNumProportion = new StringBuilder();
                    brickNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    brickNumProportion = new StringBuilder();
                    brickNumProportion.append(format + "%");
                }

            }
            //砖混面积抽样率，详查/普查
            StringBuilder brickAreaProportion = null;
            if (brickAreaXC > 0L) {
                double num = (brickStructureArea / (double) brickAreaXC) * 100;
                if (num > 100){
                    brickAreaProportion = new StringBuilder();
                    brickAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    brickAreaProportion = new StringBuilder();
                    brickAreaProportion.append(format + "%");
                }
            }
            //砖木栋数抽样率，详查/普查
            StringBuilder brickwoodNumProportion = null;
            if (brickNumXC > 0L) {
                double num = (brickwoodStructureNum / (double) brickNumXC) * 100;
                if (num > 100){
                    brickwoodNumProportion = new StringBuilder();
                    brickwoodNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    brickwoodNumProportion = new StringBuilder();
                    brickwoodNumProportion.append(format + "%");
                }
            }
            //砖木面积抽样率，详查/普查
            StringBuilder brickwoodAreaProportion = null;
            if (brickAreaXC > 0L) {
                double num = (brickwoodStructureArea / (double) brickAreaXC) * 100;
                if (num > 100){
                    brickwoodAreaProportion = new StringBuilder();
                    brickwoodAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    brickwoodAreaProportion = new StringBuilder();
                    brickwoodAreaProportion.append(format + "%");
                }
            }
            //多层钢筋混凝土结构栋数抽样率，详查/普查
            StringBuilder mulConcreteStructureNumXCProportion = null;
            if (mulConcreteStructureNumXC > 0L) {
                double num = (mulConcreteStructureNum / (double) mulConcreteStructureNumXC) * 100;
                if (num > 100){
                    mulConcreteStructureNumXCProportion = new StringBuilder();
                    mulConcreteStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    mulConcreteStructureNumXCProportion = new StringBuilder();
                    mulConcreteStructureNumXCProportion.append(format + "%");
                }
            }
            //多层钢筋混凝土结构面积抽样率，详查/普查
            StringBuilder mulConcreteStructureAreaXCProportion = null;
            if (mulConcreteStructureAreaXC > 0L) {
                double num = (mulConcreteStructureArea / (double) mulConcreteStructureAreaXC) * 100;
                if (num > 100){
                    mulConcreteStructureAreaXCProportion = new StringBuilder();
                    mulConcreteStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    mulConcreteStructureAreaXCProportion = new StringBuilder();
                    mulConcreteStructureAreaXCProportion.append(format + "%");
                }
            }
            //高层结构结构栋数抽样率，详查/普查
            StringBuilder highStructureNumXCProportion = null;
            if (highStructureNumXC > 0L) {
                double num = (highStructureNum / (double) highStructureNumXC) * 100;
                if (num > 100){
                    highStructureNumXCProportion = new StringBuilder();
                    highStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    highStructureNumXCProportion = new StringBuilder();
                    highStructureNumXCProportion.append(format + "%");
                }
            }
            //高层结构结构面积抽样率，详查/普查
            StringBuilder highStructureAreaXCProportion = null;
            if (highStructureAreaXC > 0L) {
                double num = (highStructureArea / (double) highStructureAreaXC) * 100;
                if (num > 100){
                    highStructureAreaXCProportion = new StringBuilder();
                    highStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    highStructureAreaXCProportion = new StringBuilder();
                    highStructureAreaXCProportion.append(format + "%");
                }
            }
            //工业厂房栋数抽样率，详查/普查
            StringBuilder factoryStructureNumXCProportion = null;
            if (factoryStructureNumXC > 0L) {
                double num = (factoryStructureNum / (double) factoryStructureNumXC) * 100;
                if (num > 100){
                    factoryStructureNumXCProportion = new StringBuilder();
                    factoryStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    factoryStructureNumXCProportion = new StringBuilder();
                    factoryStructureNumXCProportion.append(format + "%");
                }
            }
            //工业厂房面积抽样率，详查/普查
            StringBuilder factoryStructureAreaXCProportion = null;
            if (factoryStructureAreaXC > 0L) {
                double num = (factoryStructureArea / (double) factoryStructureAreaXC) * 100;
                if (num > 100){
                    factoryStructureAreaXCProportion = new StringBuilder();
                    factoryStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    factoryStructureAreaXCProportion = new StringBuilder();
                    factoryStructureAreaXCProportion.append(format + "%");
                }
            }
            //空旷结构栋数抽样率，详查/普查
            StringBuilder wideStructureNumXCProportion = null;
            if (wideStructureNumXC > 0L) {
                double num = (wideStructureNum / (double) wideStructureNumXC) * 100;
                if (num > 100){
                    wideStructureNumXCProportion = new StringBuilder();
                    wideStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    wideStructureNumXCProportion = new StringBuilder();
                    wideStructureNumXCProportion.append(format + "%");
                }
            }
            //空旷结构面积抽样率，详查/普查
            StringBuilder wideStructureAreaXCProportion = null;
            if (wideStructureAreaXC > 0L) {
                double num = (wideStructureArea / (double) wideStructureAreaXC) * 100;
                if (num > 100){
                    wideStructureAreaXCProportion = new StringBuilder();
                    wideStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    wideStructureAreaXCProportion = new StringBuilder();
                    wideStructureAreaXCProportion.append(format + "%");
                }
            }
            //土木结构栋数抽样率，详查/普查
            StringBuilder buildingStructureNumXCProportion = null;
            if (buildingStructureNumXC > 0L) {
                double num = (buildingStructureNum / (double) buildingStructureNumXC) * 100;
                if (num > 100){
                    buildingStructureNumXCProportion = new StringBuilder();
                    buildingStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    buildingStructureNumXCProportion = new StringBuilder();
                    buildingStructureNumXCProportion.append(format + "%");
                }
            }
            //土木结构面积抽样率，详查/普查
            StringBuilder buildingStructureAreaXCProportion = null;
            if (buildingStructureAreaXC > 0L) {
                double num = (buildingStructureArea / (double) buildingStructureAreaXC) * 100;
                if (num > 100){
                    buildingStructureAreaXCProportion = new StringBuilder();
                    buildingStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    buildingStructureAreaXCProportion = new StringBuilder();
                    buildingStructureAreaXCProportion.append(format + "%");
                }
            }
            //木结构栋数抽样率，详查/普查
            StringBuilder woodStructureNumXCProportion = null;
            if (woodStructureNumXC > 0L) {
                double num = (woodStructureNum / (double) woodStructureNumXC) * 100;
                if (num > 100){
                    woodStructureNumXCProportion = new StringBuilder();
                    woodStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    woodStructureNumXCProportion = new StringBuilder();
                    woodStructureNumXCProportion.append(format + "%");
                }
            }
            //木结构面积抽样率，详查/普查
            StringBuilder woodStructureAreaXCProportion = null;
            if (woodStructureAreaXC > 0L) {
                double num = (woodStructureArea / (double) woodStructureAreaXC) * 100;
                if (num > 100){
                    woodStructureAreaXCProportion = new StringBuilder();
                    woodStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    woodStructureAreaXCProportion = new StringBuilder();
                    woodStructureAreaXCProportion.append(format + "%");
                }
            }
            //otherStructureNumXC
            //其他结构栋数抽样率，详查/普查
            StringBuilder otherStructureNumXCProportion = null;
            if (otherStructureNumXC > 0L) {
                double num = (otherStructureNum / (double) otherStructureNumXC) * 100;
                if (num > 100){
                    otherStructureNumXCProportion = new StringBuilder();
                    otherStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    otherStructureNumXCProportion = new StringBuilder();
                    otherStructureNumXCProportion.append(format + "%");
                }
            }
            //其他结构面积抽样率，详查/普查
            StringBuilder otherStructureAreaXCProportion = null;
            if (otherStructureAreaXC > 0L) {
                double num = (otherStructureArea / (double) otherStructureAreaXC) * 100;
                if (num > 100){
                    otherStructureAreaXCProportion = new StringBuilder();
                    otherStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    otherStructureAreaXCProportion = new StringBuilder();
                    otherStructureAreaXCProportion.append(format + "%");
                }
            }
            //石构栋数抽样率，详查/普查
            StringBuilder stoneStructureNumXCProportion = null;
            if (stoneStructureNumXC > 0L) {
                double num = (stoneStructureNum / (double) stoneStructureNumXC) * 100;
                if (num > 100){
                    stoneStructureNumXCProportion = new StringBuilder();
                    stoneStructureNumXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    stoneStructureNumXCProportion = new StringBuilder();
                    stoneStructureNumXCProportion.append(format + "%");
                }
            }
            //石构面积抽样率，详查/普查
            StringBuilder stoneStructureAreaXCProportion = null;
            if (stoneStructureAreaXC > 0L) {
                double num = (stoneStructureArea / (double) stoneStructureAreaXC) * 100;
                if (num > 100){
                    stoneStructureAreaXCProportion = new StringBuilder();
                    stoneStructureAreaXCProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    stoneStructureAreaXCProportion = new StringBuilder();
                    stoneStructureAreaXCProportion.append(format + "%");
                }
            }
            //城镇砖混栋数占比
            StringBuilder cityBrickNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskBrickCount + noCityTaskBrickCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    cityBrickNumProportion = new StringBuilder();
                    cityBrickNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityBrickNumProportion = new StringBuilder();
                    cityBrickNumProportion.append(format + "%");
                }
            }
            //城镇砖混面积占比
            StringBuilder cityBrickAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskBrickArea + noCityTaskBrickArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    cityBrickAreaProportion = new StringBuilder();
                    cityBrickAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityBrickAreaProportion = new StringBuilder();
                    cityBrickAreaProportion.append(format + "%");
                }
            }
            //底层混凝土柱-上部砖混栋数占比
            StringBuilder cityTopBrickNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskTopBrickCount + noCityTaskTopBrickCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    cityTopBrickNumProportion = new StringBuilder();
                    cityTopBrickNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityTopBrickNumProportion = new StringBuilder();
                    cityTopBrickNumProportion.append(format + "%");
                }
            }
            //底层混凝土柱-上部砖混面积占比
            StringBuilder cityTopBrickAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskTopBrickArea + noCityTaskTopBrickArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    cityTopBrickAreaProportion = new StringBuilder();
                    cityTopBrickAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityTopBrickAreaProportion = new StringBuilder();
                    cityTopBrickAreaProportion.append(format + "%");
                }
            }
            //钢筋混凝土栋数占比
            StringBuilder cityReinforcedConcreteNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskReinforcedConcreteCount + noCityTaskReinforcedConcreteCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    cityReinforcedConcreteNumProportion = new StringBuilder();
                    cityReinforcedConcreteNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityReinforcedConcreteNumProportion = new StringBuilder();
                    cityReinforcedConcreteNumProportion.append(format + "%");
                }
            }
            //钢筋混凝土面积占比
            StringBuilder cityReinforcedConcreteAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskReinforcedConcreteArea + noCityTaskReinforcedConcreteArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    cityReinforcedConcreteAreaProportion = new StringBuilder();
                    cityReinforcedConcreteAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityReinforcedConcreteAreaProportion = new StringBuilder();
                    cityReinforcedConcreteAreaProportion.append(format + "%");
                }
            }
            //砖木栋数占比
            StringBuilder cityBrickWoodNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskBrickWoodCount + noCityTaskBrickWoodCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    cityBrickWoodNumProportion = new StringBuilder();
                    cityBrickWoodNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityBrickWoodNumProportion = new StringBuilder();
                    cityBrickWoodNumProportion.append(format + "%");
                }
            }
            //砖木面积占比
            StringBuilder cityBrickWoodAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskBrickWoodArea + noCityTaskBrickWoodArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    cityBrickWoodAreaProportion = new StringBuilder();
                    cityBrickWoodAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityBrickWoodAreaProportion = new StringBuilder();
                    cityBrickWoodAreaProportion.append(format + "%");
                }
            }
            //钢结构栋数占比
            StringBuilder citySteelStructureNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskSteelStructureCount + noCityTaskSteelStructureCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    citySteelStructureNumProportion = new StringBuilder();
                    citySteelStructureNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    citySteelStructureNumProportion = new StringBuilder();
                    citySteelStructureNumProportion.append(format + "%");
                }
            }
            //钢结构面积占比
            StringBuilder citySteelStructureAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskSteelStructureArea + noCityTaskSteelStructureArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    citySteelStructureAreaProportion = new StringBuilder();
                    citySteelStructureAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    citySteelStructureAreaProportion = new StringBuilder();
                    citySteelStructureAreaProportion.append(format + "%");
                }
            }
            //木结构栋数占比
            StringBuilder cityWoodStructureNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskWoodStructureCount + noCityTaskWoodStructureCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    cityWoodStructureNumProportion = new StringBuilder();
                    cityWoodStructureNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityWoodStructureNumProportion = new StringBuilder();
                    cityWoodStructureNumProportion.append(format + "%");
                }
            }
            //木结构面积占比
            StringBuilder cityWoodStructureAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskWoodStructureArea + noCityTaskWoodStructureArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    cityWoodStructureAreaProportion = new StringBuilder();
                    cityWoodStructureAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityWoodStructureAreaProportion = new StringBuilder();
                    cityWoodStructureAreaProportion.append(format + "%");
                }
            }
            //其他栋数占比
            StringBuilder cityOtherNumProportion = null;
            if (cityCountNum > 0L) {
                double num = ((cityTaskOtherCount + noCityTaskOtherCount) / (double) cityCountNum) * 100;
                if (num > 100){
                    cityOtherNumProportion = new StringBuilder();
                    cityOtherNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityOtherNumProportion = new StringBuilder();
                    cityOtherNumProportion.append(format + "%");
                }

            }
            //其他面积占比
            StringBuilder cityOtherAreaProportion = null;
            if (cityCountArea > 0L) {
                double num = ((cityTaskOtherArea + noCityTaskOtherArea) / (double) cityCountArea) * 100;
                if (num > 100){
                    cityOtherAreaProportion = new StringBuilder();
                    cityOtherAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    cityOtherAreaProportion = new StringBuilder();
                    cityOtherAreaProportion.append(format + "%");
                }
            }

            //砖（砌块）混栋数占比
            StringBuilder villageBrickNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseBrickCount + villagePubHouseBrickCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageBrickNumProportion = new StringBuilder();
                    villageBrickNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageBrickNumProportion = new StringBuilder();
                    villageBrickNumProportion.append(format + "%");
                }
            }
            //砖（砌块）混栋数占比
            StringBuilder villageBrickAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseBrickArea + villagePubHouseBrickArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageBrickAreaProportion = new StringBuilder();
                    villageBrickAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageBrickAreaProportion = new StringBuilder();
                    villageBrickAreaProportion.append(format + "%");
                }
            }
            //低层框架栋数占比
            StringBuilder villageLowerFrameNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseLowerFrameCount + villagePubHouseLowerFrameCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageLowerFrameNumProportion = new StringBuilder();
                    villageLowerFrameNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageLowerFrameNumProportion = new StringBuilder();
                    villageLowerFrameNumProportion.append(format + "%");
                }
            }
            //底层框架面积占比
            StringBuilder villageLowerFrameAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseLowerFrameArea + villagePubHouseLowerFrameArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageLowerFrameAreaProportion = new StringBuilder();
                    villageLowerFrameAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageLowerFrameAreaProportion = new StringBuilder();
                    villageLowerFrameAreaProportion.append(format + "%");
                }
            }
            //轻钢（钢）装配式数量占比
            StringBuilder villageSteelAssemblyNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseSteelAssemblyCount + villagePubHouseSteelAssemblyCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageSteelAssemblyNumProportion = new StringBuilder();
                    villageSteelAssemblyNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageSteelAssemblyNumProportion = new StringBuilder();
                    villageSteelAssemblyNumProportion.append(format + "%");
                }
            }
            //轻钢（钢）装配式面积占比
            StringBuilder villageSteelAssemblyAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseSteelAssemblyArea + villagePubHouseSteelAssemblyArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageSteelAssemblyAreaProportion = new StringBuilder();
                    villageSteelAssemblyAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageSteelAssemblyAreaProportion = new StringBuilder();
                    villageSteelAssemblyAreaProportion.append(format + "%");
                }
            }
            //混凝土装配式数量占比
            StringBuilder villageConcreteAssemblyNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseConcreteAssemblyCount + villagePubHouseConcreteAssemblyCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageConcreteAssemblyNumProportion = new StringBuilder();
                    villageConcreteAssemblyNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageConcreteAssemblyNumProportion = new StringBuilder();
                    villageConcreteAssemblyNumProportion.append(format + "%");
                }
            }
            //混凝土装配式面积占比
            StringBuilder villageConcreteAssemblyAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseConcreteAssemblyArea + villagePubHouseConcreteAssemblyArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageConcreteAssemblyAreaProportion = new StringBuilder();
                    villageConcreteAssemblyAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageConcreteAssemblyAreaProportion = new StringBuilder();
                    villageConcreteAssemblyAreaProportion.append(format + "%");
                }
            }
            //砖木数量占比
            StringBuilder villageBrickWoodNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseBrickWoodCount + villagePubHouseBrickWoodCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageBrickWoodNumProportion = new StringBuilder();
                    villageBrickWoodNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageBrickWoodNumProportion = new StringBuilder();
                    villageBrickWoodNumProportion.append(format + "%");
                }
            }
            //砖木装配式面积占比
            StringBuilder villageBrickWoodAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseBrickWoodArea + villagePubHouseBrickWoodArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageBrickWoodAreaProportion = new StringBuilder();
                    villageBrickWoodAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageBrickWoodAreaProportion = new StringBuilder();
                    villageBrickWoodAreaProportion.append(format + "%");
                }
            }
            //土木数量占比
            StringBuilder villageCivilWoodNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseCivilWoodCount + villagePubHouseCivilWoodCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageCivilWoodNumProportion = new StringBuilder();
                    villageCivilWoodNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageCivilWoodNumProportion = new StringBuilder();
                    villageCivilWoodNumProportion.append(format + "%");
                }
            }
            //土木面积占比
            StringBuilder villageCivilWoodAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseCivilWoodArea + villagePubHouseCivilWoodArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageCivilWoodAreaProportion = new StringBuilder();
                    villageCivilWoodAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageCivilWoodAreaProportion = new StringBuilder();
                    villageCivilWoodAreaProportion.append(format + "%");
                }
            }
            //石木数量占比
            StringBuilder villageStoneWoodNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseStoneWoodCount + villagePubHouseStoneWoodCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageStoneWoodNumProportion = new StringBuilder();
                    villageStoneWoodNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageStoneWoodNumProportion = new StringBuilder();
                    villageStoneWoodNumProportion.append(format + "%");
                }
            }
            //石木面积占比
            StringBuilder villageStoneWoodAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseStoneWoodArea + villagePubHouseStoneWoodArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageStoneWoodAreaProportion = new StringBuilder();
                    villageStoneWoodAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageStoneWoodAreaProportion = new StringBuilder();
                    villageStoneWoodAreaProportion.append(format + "%");
                }
            }
            //木结构数量占比
            StringBuilder villageWoodStructureNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseWoodStructureCount + villagePubHouseWoodStructureCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageWoodStructureNumProportion = new StringBuilder();
                    villageWoodStructureNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageWoodStructureNumProportion = new StringBuilder();
                    villageWoodStructureNumProportion.append(format + "%");
                }
            }
            //木结构面积占比
            StringBuilder villageWoodStructureAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseWoodStructureArea + villagePubHouseWoodStructureArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageWoodStructureAreaProportion = new StringBuilder();
                    villageWoodStructureAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageWoodStructureAreaProportion = new StringBuilder();
                    villageWoodStructureAreaProportion.append(format + "%");
                }
            }
            //窑洞数量占比
            StringBuilder villageCaveDwellingNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseCaveDwellingCount + villageHouseCaveDwellingCount) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageCaveDwellingNumProportion = new StringBuilder();
                    villageCaveDwellingNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageCaveDwellingNumProportion = new StringBuilder();
                    villageCaveDwellingNumProportion.append(format + "%");
                }
            }
            //窑洞面积占比
            StringBuilder villageCaveDwellingAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseCaveDwellingArea + villagePubHouseCivilWoodArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageCaveDwellingAreaProportion = new StringBuilder();
                    villageCaveDwellingAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageCaveDwellingAreaProportion = new StringBuilder();
                    villageCaveDwellingAreaProportion.append(format + "%");
                }
            }
            //混杂结构（砖/砌块/土/石）数量占比
            StringBuilder villageMixedStructureNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseMixedStructureCount + villagePubHouseMixedStructureArea) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageMixedStructureNumProportion = new StringBuilder();
                    villageMixedStructureNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageMixedStructureNumProportion = new StringBuilder();
                    villageMixedStructureNumProportion.append(format + "%");
                }
            }
            //混杂结构（砖/砌块/土/石）面积占比
            StringBuilder villageMixedStructureAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseMixedStructureArea + villagePubHouseMixedStructureArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageMixedStructureAreaProportion = new StringBuilder();
                    villageMixedStructureAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageMixedStructureAreaProportion = new StringBuilder();
                    villageMixedStructureAreaProportion.append(format + "%");
                }
            }
            //其它数量占比
            StringBuilder villageOtherNumProportion = null;
            if (villageCountNum > 0L) {
                double num = ((villageHouseOtherCount + villagePubHouseOtherArea) / (double) villageCountNum) * 100;
                if (num > 100){
                    villageOtherNumProportion = new StringBuilder();
                    villageOtherNumProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageOtherNumProportion = new StringBuilder();
                    villageOtherNumProportion.append(format + "%");
                }
            }
            //其它面积占比
            StringBuilder villageOtherAreaProportion = null;
            if (villageCountArea > 0L) {
                double num = ((villageHouseOtherArea + villagePubHouseOtherArea) / (double) villageCountArea) * 100;
                if (num > 100){
                    villageOtherAreaProportion = new StringBuilder();
                    villageOtherAreaProportion.append("-");
                }else {
                    String format = String.format("%.2f", num);
                    villageOtherAreaProportion = new StringBuilder();
                    villageOtherAreaProportion.append(format + "%");
                }
            }

            //模板赋值
            //详查建筑物结构类型总数统计图
            String imageWorkNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingStructureNum.png";
            //详查建筑物总数统计图base64
            String buildingCountImageNum = ImageUtil.getImageBase(imageWorkNumPath);
            //详查建筑物面积统计图获取
            String imageWorkAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingStructureArea.png";
            //详查建筑物总数统计图base64
            String buildingCountImageArea = ImageUtil.getImageBase(imageWorkAreaPath);

            //详查数据年代图获取
            String buildingAgeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingAgeNum.png";
            //获取年代图base64
            String buildingAgeNum = ImageUtil.getImageBase(buildingAgeNumPath);
            String buildingAgeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingAgeArea.png";
            //获取年代图base64
            String buildingAgeArea = ImageUtil.getImageBase(buildingAgeAreaPath);


            //抗震设防烈度图获取
            String buildingIntensityNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingIntensityNum.png";
            //获取抗震设防烈度图base64
            String buildingIntensityNum = ImageUtil.getImageBase(buildingIntensityNumPath);
            String buildingIntensityAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingIntensityArea.png";
            //获取抗震设防烈度图base64
            String buildingIntensityArea = ImageUtil.getImageBase(buildingIntensityAreaPath);

            //获取砖混结构外墙厚度统计图
            String brickOutWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickOutWallThickNum.png";
            //获取砖混结构外墙厚度图base64
            String brickOutWallThickNum = ImageUtil.getImageBase(brickOutWallThickNumPath);
            String brickOutWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickOutWallThickArea.png";
            //获取砖混结构外墙厚度图base64
            String brickOutWallThickArea = ImageUtil.getImageBase(brickOutWallThickAreaPath);

            //获取砖混结构内墙厚度统计图
            String brickInWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickInWallThickNum.png";
            //获取砖混结构内墙厚度图base64
            String brickInWallThickNum = ImageUtil.getImageBase(brickInWallThickNumPath);
            String brickInWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickInWallThickArea.png";
            //获取砖混结构内墙厚度图base64
            String brickInWallThickArea = ImageUtil.getImageBase(brickInWallThickAreaPath);

            //获取砖混结构墙体材质统计图
            String brickWallMaterialNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickWallMaterialNum.png";
            //获取砖混结构墙体材质图base64
            String brickWallMaterialNum = ImageUtil.getImageBase(brickWallMaterialNumPath);
            String brickWallMaterialAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickWallMaterialArea.png";
            //获取砖混结构墙体材质图base64
            String brickWallMaterialArea = ImageUtil.getImageBase(brickWallMaterialAreaPath);

            //获取砖混结构砂浆类型统计图
            String brickMortarTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickMortarTypeNum.png";
            //获取砖混结构砂浆类型图base64
            String brickMortarTypeNum = ImageUtil.getImageBase(brickMortarTypeNumPath);
            String brickMortarTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickMortarTypeArea.png";
            //获取砖混结构砂浆类型图base64
            String brickMortarTypeArea = ImageUtil.getImageBase(brickMortarTypeAreaPath);

            //获取砖混结构砂浆强度统计图
            String brickMortarStrengthNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickMortarStrengthNum.png";
            //获取砖混结构砂浆强度图base64
            String brickMortarStrengthNum = ImageUtil.getImageBase(brickMortarStrengthNumPath);
            String brickMortarStrengthAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickMortarStrengthArea.png";
            //获取砖混结构砂浆强度图base64
            String brickMortarStrengthArea = ImageUtil.getImageBase(brickMortarStrengthAreaPath);

            //获取砖混结构屋盖类别统计图
            String brickRoofTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickRoofTypeNum.png";
            //获取砖混结构屋盖类别图base64
            String brickRoofTypeNum = ImageUtil.getImageBase(brickRoofTypeNumPath);
            String brickRoofTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickRoofTypeArea.png";
            //获取砖混结构屋盖类别图base64
            String brickRoofTypeArea = ImageUtil.getImageBase(brickRoofTypeAreaPath);

            //获取砖混结构楼盖类别统计图
            String brickFloorTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickFloorTypeNum.png";
            //获取砖混结构楼盖类别图base64
            String brickFloorTypeNum = ImageUtil.getImageBase(brickFloorTypeNumPath);
            String brickFloorTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickFloorTypeArea.png";
            //获取砖混结构楼盖类别图base64
            String brickFloorTypeArea = ImageUtil.getImageBase(brickFloorTypeAreaPath);

            //获取砖混结构圈梁设置统计图
            String brickJlInstallNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickJlInstallNum.png";
            //获取砖混结构圈梁设置图base64
            String brickJlInstallNum = ImageUtil.getImageBase(brickJlInstallNumPath);
            String brickJlInstallAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickJlInstallArea.png";
            //获取砖混结构圈梁设置图base64
            String brickJlInstallArea = ImageUtil.getImageBase(brickJlInstallAreaPath);

            //获取砖木结构外墙厚度统计图
            String brickwoodOutWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodOutWallThickNum.png";
            //获取砖木结构外墙厚度图base64
            String brickwoodOutWallThickNum = ImageUtil.getImageBase(brickwoodOutWallThickNumPath);
            String brickwoodOutWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodOutWallThickArea.png";
            //获取砖木结构外墙厚度图base64
            String brickwoodOutWallThickArea = ImageUtil.getImageBase(brickwoodOutWallThickAreaPath);

            //获取砖木结构外内墙厚度统计图
            String brickwoodInWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodInWallThickNum.png";
            //获取砖木结构外内墙厚度图base64
            String brickwoodInWallThickNum = ImageUtil.getImageBase(brickwoodInWallThickNumPath);
            String brickwoodInWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodInWallThickArea.png";
            //获取砖木结构外内墙厚度图base64
            String brickwoodInWallThickArea = ImageUtil.getImageBase(brickwoodInWallThickAreaPath);


            //获取砖木结构外墙体材质统计图
            String brickwoodWallMaterialNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodWallMaterialNum.png";
            //获取砖木结构外墙体材质图base64
            String brickwoodWallMaterialNum = ImageUtil.getImageBase(brickwoodWallMaterialNumPath);
            String brickwoodWallMaterialAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodWallMaterialArea.png";
            //获取砖木结构外墙体材质图base64
            String brickwoodWallMaterialArea = ImageUtil.getImageBase(brickwoodWallMaterialAreaPath);

            //获取砖木结构外砂浆类型统计图
            String brickwoodMortarTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodMortarTypeNum.png";
            //获取砖木结构外砂浆类型图base64
            String brickwoodMortarTypeNum = ImageUtil.getImageBase(brickwoodMortarTypeNumPath);
            String brickwoodMortarTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodMortarTypeArea.png";
            //获取砖木结构外砂浆类型图base64
            String brickwoodMortarTypeArea = ImageUtil.getImageBase(brickwoodMortarTypeAreaPath);

            //获取砖木结构外砂浆强度统计图
            String brickwoodMortarStrengthNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodMortarStrengthNum.png";
            //获取砖木结构外砂浆强度图base64
            String brickwoodMortarStrengthNum = ImageUtil.getImageBase(brickwoodMortarStrengthNumPath);
            String brickwoodMortarStrengthAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodMortarStrengthArea.png";
            //获取砖木结构外砂浆强度图base64
            String brickwoodMortarStrengthArea = ImageUtil.getImageBase(brickwoodMortarStrengthAreaPath);

            //获取砖木结构外楼盖类别统计图
            String brickwoodFloorTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodFloorTypeNum.png";
            //获取砖木结构外楼盖类别图base64
            String brickwoodFloorTypeNum = ImageUtil.getImageBase(brickwoodFloorTypeNumPath);
            String brickwoodFloorTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "brickwoodFloorTypeArea.png";
            //获取砖木结构外楼盖类别图base64
            String brickwoodFloorTypeArea = ImageUtil.getImageBase(brickwoodFloorTypeAreaPath);

            //获取多层钢筋混凝土结构柱混凝土强度等级统计图
            String mulZhntqdLevelNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulZhntqdLevelNum.png";
            //获取多层钢筋混凝土结构柱混凝土强度等级图base64
            String mulZhntqdLevelNum = ImageUtil.getImageBase(mulZhntqdLevelNumPath);
            String mulZhntqdLevelAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulZhntqdLevelArea.png";
            //获取多层钢筋混凝土结构柱混凝土强度等级图base64
            String mulZhntqdLevelArea = ImageUtil.getImageBase(mulZhntqdLevelAreaPath);

            //获取多层钢筋混凝土结构最大柱间距统计图
            String mulZdzSpanNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulZdzSpanNum.png";
            //获取多层钢筋混凝土结构最大柱间距图base64
            String mulZdzSpanNum = ImageUtil.getImageBase(mulZdzSpanNumPath);
            String mulZdzSpanAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulZdzSpanArea.png";
            //获取多层钢筋混凝土结构最大柱间距图base64
            String mulZdzSpanArea = ImageUtil.getImageBase(mulZdzSpanAreaPath);

            //获取多层钢筋混凝土结构剪力墙混凝土强度等级统计图
            String mulJlqhntqdLevelNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulJlqhntqdLevelNum.png";
            //获取多层钢筋混凝土结构剪力墙混凝土强度等级图base64
            String mulJlqhntqdLevelNum = ImageUtil.getImageBase(mulJlqhntqdLevelNumPath);
            String mulJlqhntqdLevelAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulJlqhntqdLevelArea.png";
            //获取多层钢筋混凝土结构剪力墙混凝土强度等级图base64
            String mulJlqhntqdLevelArea = ImageUtil.getImageBase(mulJlqhntqdLevelAreaPath);

            //获取多层钢筋混凝土结构剪力墙最大间距统计图
            String mulJlqzdSpanNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulJlqzdSpanNum.png";
            //获取多层钢筋混凝土结构剪力墙最大间距图base64
            String mulJlqzdSpanNum = ImageUtil.getImageBase(mulJlqzdSpanNumPath);
            String mulJlqzdSpanAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulJlqzdSpanArea.png";
            //获取多层钢筋混凝土结构剪力墙最大间距图base64
            String mulJlqzdSpanArea = ImageUtil.getImageBase(mulJlqzdSpanAreaPath);

            //获取多层钢筋混凝土结构剪力墙厚度统计图
            String mulShearwellThicknessNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulShearwellThicknessNum.png";
            //获取多层钢筋混凝土结构剪力墙厚度图base64
            String mulShearwellThicknessNum = ImageUtil.getImageBase(mulShearwellThicknessNumPath);
            String mulShearwellThicknessAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulShearwellThicknessArea.png";
            //获取多层钢筋混凝土结构剪力墙厚度图base64
            String mulShearwellThicknessArea = ImageUtil.getImageBase(mulShearwellThicknessAreaPath);

            //获取多层钢筋混凝土结构屋盖类别统计图
            String mulRoofTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulRoofTypeNum.png";
            //获取多层钢筋混凝土结构屋盖类别图base64
            String mulRoofTypeNum = ImageUtil.getImageBase(mulRoofTypeNumPath);
            String mulRoofTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulRoofTypeArea.png";
            //获取多层钢筋混凝土结构屋盖类别图base64
            String mulRoofTypeArea = ImageUtil.getImageBase(mulRoofTypeAreaPath);

            //获取多层钢筋混凝土结构楼盖类别统计图
            String mulFloorTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulFloorTypeNum.png";
            //获取多层钢筋混凝土结构楼盖类别图base64
            String mulFloorTypeNum = ImageUtil.getImageBase(mulFloorTypeNumPath);
            String mulFloorTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "mulFloorTypeArea.png";
            //获取多层钢筋混凝土结构楼盖类别图base64
            String mulFloorTypeArea = ImageUtil.getImageBase(mulFloorTypeAreaPath);

            //获取高层结构柱混凝土强度等级统计图
            String heightZhntqdLevelNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightZhntqdLevelNum.png";
            //获取高层结构柱混凝土强度等级图base64
            String heightZhntqdLevelNum = ImageUtil.getImageBase(heightZhntqdLevelNumPath);
            String heightZhntqdLevelAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightZhntqdLevelArea.png";
            //获取高层结构柱混凝土强度等级图base64
            String heightZhntqdLevelArea = ImageUtil.getImageBase(heightZhntqdLevelAreaPath);

           /* //获取高层结构主要柱截面尺寸统计图
            String heightZyzjmSizePath = configBeanValue.wordImage + File.separator + timeStamp  + "heightZyzjmSize.png";
            //获取高层结构主要柱截面尺寸图base64
            String heightZyzjmSize = ImageUtil.getImageBase(heightZyzjmSizePath);*/
            //获取高层结构最大柱间距统计图
            String heightZdzSpanNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightZdzSpanNum.png";
            //获取高层结构最大柱间距图base64
            String heightZdzSpanNum = ImageUtil.getImageBase(heightZdzSpanNumPath);
            String heightZdzSpanAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightZdzSpanArea.png";
            //获取高层结构最大柱间距图base64
            String heightZdzSpanArea = ImageUtil.getImageBase(heightZdzSpanAreaPath);

            //获取高层结构剪力墙混凝土强度等级统计图
            String heightJlqhntqdLevelNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightJlqhntqdLevelNum.png";
            //获取高层结构剪力墙混凝土强度等级图base64
            String heightJlqhntqdLevelNum = ImageUtil.getImageBase(heightJlqhntqdLevelNumPath);
            String heightJlqhntqdLevelAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightJlqhntqdLevelArea.png";
            //获取高层结构剪力墙混凝土强度等级图base64
            String heightJlqhntqdLevelArea = ImageUtil.getImageBase(heightJlqhntqdLevelAreaPath);

            //获取高层结构剪力墙最大间距统计图
            String heightJlqzdSpanNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightJlqzdSpanNum.png";
            //获取高层结构剪力墙最大间距图base64
            String heightJlqzdSpanNum = ImageUtil.getImageBase(heightJlqzdSpanNumPath);
            String heightJlqzdSpanAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightJlqzdSpanArea.png";
            //获取高层结构剪力墙最大间距图base64
            String heightJlqzdSpanArea = ImageUtil.getImageBase(heightJlqzdSpanAreaPath);

            //获取高层结构剪力墙厚度统计图
            String heightShearwellThicknessNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightShearwellThicknessNum.png";
            //获取高层结构剪力墙厚度图base64
            String heightShearwellThicknessNum = ImageUtil.getImageBase(heightShearwellThicknessNumPath);
            String heightShearwellThicknessAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightShearwellThicknessArea.png";
            //获取高层结构剪力墙厚度图base64
            String heightShearwellThicknessArea = ImageUtil.getImageBase(heightShearwellThicknessAreaPath);

            //获取高层结构屋盖类别统计图
            String heightRoofTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightRoofTypeNum.png";
            //获取高层结构屋盖类别图base64
            String heightRoofTypeNum = ImageUtil.getImageBase(heightRoofTypeNumPath);
            String heightRoofTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightRoofTypeArea.png";
            //获取高层结构屋盖类别图base64
            String heightRoofTypeArea = ImageUtil.getImageBase(heightRoofTypeAreaPath);

            //获取高层结构楼盖类别统计图
            String heightFloorTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightFloorTypeNum.png";
            //获取高层结构楼盖类别图base64
            String heightFloorTypeNum = ImageUtil.getImageBase(heightFloorTypeNumPath);
            String heightFloorTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "heightFloorTypeArea.png";
            //获取高层结构楼盖类别图base64
            String heightFloorTypeArea = ImageUtil.getImageBase(heightFloorTypeAreaPath);

            //获取工业厂房结构排架柱类型统计图
            String factoryBentFrameColTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryBentFrameColTypeNum.png";
            //获取工业厂房结构排架柱类型图base64
            String factoryBentFrameColTypeNum = ImageUtil.getImageBase(factoryBentFrameColTypeNumPath);
            String factoryBentFrameColTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryBentFrameColTypeArea.png";
            //获取工业厂房结构排架柱类型图base64
            String factoryBentFrameColTypeArea = ImageUtil.getImageBase(factoryBentFrameColTypeAreaPath);

            //获取工业厂结构各跨跨度统计图
            String factorySpansNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "factorySpansNum.png";
            //获取工业厂房结构各跨跨度图base64
            String factorySpansNum = ImageUtil.getImageBase(factorySpansNumPath);
            String factorySpansAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "factorySpansArea.png";
            //获取工业厂房结构各跨跨度图base64
            String factorySpansArea = ImageUtil.getImageBase(factorySpansAreaPath);

            //获取工业厂房结构排架柱距统计图
            String factoryBentFrameColSpaceNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryBentFrameColSpaceNum.png";
            //获取工业厂房结构排架柱距图base64
            String factoryBentFrameColSpaceNum = ImageUtil.getImageBase(factoryBentFrameColSpaceNumPath);
            String factoryBentFrameColSpaceAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryBentFrameColSpaceArea.png";
            //获取工业厂房结构排架柱距图base64
            String factoryBentFrameColSpaceArea = ImageUtil.getImageBase(factoryBentFrameColSpaceAreaPath);

            //获取工业厂房结构屋盖体系统计图
            String factoryRoofSystemNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryRoofSystemNum.png";
            //获取工业厂房结构屋盖体系图base64
            String factoryRoofSystemNum = ImageUtil.getImageBase(factoryRoofSystemNumPath);
            String factoryRoofSystemAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryRoofSystemArea.png";
            //获取工业厂房结构屋盖体系图base64
            String factoryRoofSystemArea = ImageUtil.getImageBase(factoryRoofSystemAreaPath);

            //获取工业厂房结构屋架形式统计图
            String factoryRoofTrussStyleNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryRoofTrussStyleNum.png";
            //获取工业厂房结构屋架形式图base64
            String factoryRoofTrussStyleNum = ImageUtil.getImageBase(factoryRoofTrussStyleNumPath);
            String factoryRoofTrussStyleAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryRoofTrussStyleArea.png";
            //获取工业厂房结构屋架形式图base64
            String factoryRoofTrussStyleArea = ImageUtil.getImageBase(factoryRoofTrussStyleAreaPath);

            //获取工业厂房结构圈梁道数统计图
            String factoryRingBeamNumNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryRingBeamNumNum.png";
            //获取工业厂房结构圈梁道数图base64
            String factoryRingBeamNumNum = ImageUtil.getImageBase(factoryRingBeamNumNumPath);
            String factoryRingBeamNumAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "factoryRingBeamNumArea.png";
            //获取工业厂房结构圈梁道数图base64
            String factoryRingBeamNumArea = ImageUtil.getImageBase(factoryRingBeamNumAreaPath);

            //获取空旷结构柱类型统计图
            String wideColTypePieNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideColTypePieNum.png";
            //获取空旷结构柱类型图base64
            String wideColTypePieNum = ImageUtil.getImageBase(wideColTypePieNumPath);
            String wideColTypePieAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideColTypePieArea.png";
            //获取空旷结构柱类型图base64
            String wideColTypePieArea = ImageUtil.getImageBase(wideColTypePieAreaPath);

            //获取空旷结构柱跨度统计图
            String wideColSpanNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideColSpanNum.png";
            //获取空旷结构柱跨度图base64
            String wideColSpanNum = ImageUtil.getImageBase(wideColSpanNumPath);
            String wideColSpanAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideColSpanArea.png";
            //获取空旷结构柱跨度图base64
            String wideColSpanArea = ImageUtil.getImageBase(wideColSpanAreaPath);

            //获取空旷结构柱距统计图
            String wideColSpaceNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideColSpaceNum.png";
            //获取空旷结构柱距图base64
            String wideColSpaceNum = ImageUtil.getImageBase(wideColSpaceNumPath);
            String wideColSpaceAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideColSpaceArea.png";
            //获取空旷结构柱距图base64
            String wideColSpaceArea = ImageUtil.getImageBase(wideColSpaceAreaPath);

            //获取空旷结构屋面类别统计图
            String wideWmTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideWmTypeNum.png";
            //获取空旷结构屋面类别图base64
            String wideWmTypeNum = ImageUtil.getImageBase(wideWmTypeNumPath);
            String wideWmTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideWmTypeArea.png";
            //获取空旷结构屋面类别图base64
            String wideWmTypeArea = ImageUtil.getImageBase(wideWmTypeAreaPath);

            //获取空旷结构屋架形式统计图
            String wideWjGenreNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideWjGenreNum.png";
            //获取空旷结构屋架形式图base64
            String wideWjGenreNum = ImageUtil.getImageBase(wideWjGenreNumPath);
            String wideWjGenreAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideWjGenreArea.png";
            //获取空旷结构屋架形式图base64
            String wideWjGenreArea = ImageUtil.getImageBase(wideWjGenreAreaPath);

            //获取空旷结构圈梁道数统计图
            String wideRingBeamNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideRingBeamNum.png";
            //获取空旷结构圈梁道数图base64
            String wideRingBeamNum = ImageUtil.getImageBase(wideRingBeamNumPath);
            String wideRingBeamAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "wideRingBeamArea.png";
            //获取空旷结构圈梁道数图base64
            String wideRingBeamArea = ImageUtil.getImageBase(wideRingBeamAreaPath);

            //获取土木结构墙体类型统计图
            String buildingWallTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWallTypeNum.png";
            //获取土木结构墙体类型图base64
            String buildingWallTypeNum = ImageUtil.getImageBase(buildingWallTypeNumPath);
            String buildingWallTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWallTypeArea.png";
            //获取土木结构墙体类型图base64
            String buildingWallTypeArea = ImageUtil.getImageBase(buildingWallTypeAreaPath);

            //获取土木结构墙体延性材料统计图
            String buildingQtyxclNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingQtyxclNum.png";
            //获取土木结构墙体延性材料图base64
            String buildingQtyxclNum = ImageUtil.getImageBase(buildingQtyxclNumPath);
            String buildingQtyxclAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingQtyxclArea.png";
            //获取土木结构墙体延性材料图base64
            String buildingQtyxclArea = ImageUtil.getImageBase(buildingQtyxclAreaPath);

            //获取土木结构墙体厚度统计图
            String buildingWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWallThickNum.png";
            //获取土木结构墙体厚度图base64
            String buildingWallThickNum = ImageUtil.getImageBase(buildingWallThickNumPath);
            String buildingWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWallThickArea.png";
            //获取土木结构墙体厚度图base64
            String buildingWallThickArea = ImageUtil.getImageBase(buildingWallThickAreaPath);

            //获取土木结构门窗洞口宽度统计图
            String buildingWindowWidthNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWindowWidthNum.png";
            //获取土木结构门窗洞口宽度图base64
            String buildingWindowWidthNum = ImageUtil.getImageBase(buildingWindowWidthNumPath);
            String buildingWindowWidthAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWindowWidthArea.png";
            //获取土木结构门窗洞口宽度图base64
            String buildingWindowWidthArea = ImageUtil.getImageBase(buildingWindowWidthAreaPath);

            //获取土木结构屋架材料统计图
            String buildingWmMaterialNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWmMaterialNum.png";
            //获取土木结构屋架材料图base64
            String buildingWmMaterialNum = ImageUtil.getImageBase(buildingWmMaterialNumPath);
            String buildingWmMaterialAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWmMaterialArea.png";
            //获取土木结构屋架材料图base64
            String buildingWmMaterialArea = ImageUtil.getImageBase(buildingWmMaterialAreaPath);

            //获取土木结构墙体圈梁统计图
            String buildingWallRingBeamNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWallRingBeamNum.png";
            //获取土木结构墙体圈梁图base64
            String buildingWallRingBeamNum = ImageUtil.getImageBase(buildingWallRingBeamNumPath);
            String buildingWallRingBeamAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "buildingWallRingBeamArea.png";
            //获取土木结构墙体圈梁图base64
            String buildingWallRingBeamArea = ImageUtil.getImageBase(buildingWallRingBeamAreaPath);

            //获取木结构穿斗方式统计图
            String woodCdTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodCdTypeNum.png";
            //获取木结构穿斗方式图base64
            String woodCdTypeNum = ImageUtil.getImageBase(woodCdTypeNumPath);
            String woodCdTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodCdTypeArea.png";
            //获取木结构穿斗方式图base64
            String woodCdTypeArea = ImageUtil.getImageBase(woodCdTypeAreaPath);

            //获取木结构木柱梢径统计图
            String woodMzsjNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodMzsjNum.png";
            //获取木结构木柱梢径图base64
            String woodMzsjNum = ImageUtil.getImageBase(woodMzsjNumPath);
            String woodMzsjAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodMzsjArea.png";
            //获取木结构木柱梢径图base64
            String woodMzsjArea = ImageUtil.getImageBase(woodMzsjAreaPath);

            //获取木结构围护墙体类型统计图
            String woodWallTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodWallTypeNum.png";
            //获取木结构围护墙体类型图base64
            String woodWallTypeNum = ImageUtil.getImageBase(woodWallTypeNumPath);
            String woodWallTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodWallTypeArea.png";
            //获取木结构围护墙体类型图base64
            String woodWallTypeArea = ImageUtil.getImageBase(woodWallTypeAreaPath);

            //获取木结构墙体厚度统计图
            String woodWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodWallThickNum.png";
            //获取木结构墙体厚度图base64
            String woodWallThickNum = ImageUtil.getImageBase(woodWallThickNumPath);
            String woodWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodWallThickArea.png";
            //获取木结构墙体厚度图base64
            String woodWallThickArea = ImageUtil.getImageBase(woodWallThickAreaPath);

            //获取木结构山尖墙体类型统计图
            String woodSjqtTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodSjqtTypeNum.png";
            //获取木结构山尖墙体类型图base64
            String woodSjqtTypeNum = ImageUtil.getImageBase(woodSjqtTypeNumPath);
            String woodSjqtTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodSjqtTypeArea.png";
            //获取木结构山尖墙体类型图base64
            String woodSjqtTypeArea = ImageUtil.getImageBase(woodSjqtTypeAreaPath);

            //获取木结构墙体圈梁统计图
            String woodWallRingBeamNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodWallRingBeamNum.png";
            //获取木结构墙体圈梁图base64
            String woodWallRingBeamNum = ImageUtil.getImageBase(woodWallRingBeamNumPath);
            String woodWallRingBeamAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "woodWallRingBeamArea.png";
            //获取木结构墙体圈梁图base64
            String woodWallRingBeamArea = ImageUtil.getImageBase(woodWallRingBeamAreaPath);

            //获取石结构墙体材质统计图
            String stoneWallMaterialNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneWallMaterialNum.png";
            //获取石结构墙体材质图base64
            String stoneWallMaterialNum = ImageUtil.getImageBase(stoneWallMaterialNumPath);
            String stoneWallMaterialAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneWallMaterialArea.png";
            //获取石结构墙体材质图base64
            String stoneWallMaterialArea = ImageUtil.getImageBase(stoneWallMaterialAreaPath);

            //获取石结构横墙最大间距统计图
            String stoneHqzdSpaceNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneHqzdSpaceNum.png";
            //获取石结构横墙最大间距图base64
            String stoneHqzdSpaceNum = ImageUtil.getImageBase(stoneHqzdSpaceNumPath);
            String stoneHqzdSpaceAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneHqzdSpaceArea.png";
            //获取石结构横墙最大间距图base64
            String stoneHqzdSpaceArea = ImageUtil.getImageBase(stoneHqzdSpaceAreaPath);

            //获取石结构墙体厚度统计图
            String stoneWallThickNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneWallThickNum.png";
            //获取石结构墙体厚度图base64
            String stoneWallThickNum = ImageUtil.getImageBase(stoneWallThickNumPath);
            String stoneWallThickAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneWallThickArea.png";
            //获取石结构墙体厚度图base64
            String stoneWallThickArea = ImageUtil.getImageBase(stoneWallThickAreaPath);

            //获取石结构横墙开洞面积统计图
            String stoneHqkdAreaNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneHqkdAreaNum.png";
            //获取石结构横墙开洞面积图base64
            String stoneHqkdAreaNum = ImageUtil.getImageBase(stoneHqkdAreaNumPath);
            String stoneHqkdAreaAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneHqkdAreaArea.png";
            //获取石结构横墙开洞面积图base64
            String stoneHqkdAreaArea = ImageUtil.getImageBase(stoneHqkdAreaAreaPath);

            //获取石结构屋盖类型统计图
            String stoneRoofTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneRoofTypeNum.png";
            //获取石结构屋盖类型图base64
            String stoneRoofTypeNum = ImageUtil.getImageBase(stoneRoofTypeNumPath);
            String stoneRoofTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneRoofTypeArea.png";
            //获取石结构屋盖类型图base64
            String stoneRoofTypeArea = ImageUtil.getImageBase(stoneRoofTypeAreaPath);

            //获取石结构圈梁统计图
            String stoneQlNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneQlNum.png";
            //获取石结构圈梁图base64
            String stoneQlNum = ImageUtil.getImageBase(stoneQlNumPath);
            String stoneQlAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneQlArea.png";
            //获取石结构圈梁图base64
            String stoneQlArea = ImageUtil.getImageBase(stoneQlAreaPath);

            //获取石结构四角设构造柱统计图
            String stoneSjsgzzNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneSjsgzzNum.png";
            //获取石结构四角设构造柱图base64
            String stoneSjsgzzNum = ImageUtil.getImageBase(stoneSjsgzzNumPath);
            String stoneSjsgzzAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "stoneSjsgzzArea.png";
            //获取石结构四角设构造柱图base64
            String stoneSjsgzzArea = ImageUtil.getImageBase(stoneSjsgzzAreaPath);

            //其他结构
            //获取其他结构剪力墙混凝土强度等级统计图
            String otherJlqhntqdLevelNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherJlqhntqdLevelNum.png";
            //获取其他结构剪力墙混凝土强度等级图base64
            String otherJlqhntqdLevelNum = ImageUtil.getImageBase(otherJlqhntqdLevelNumPath);
            String otherJlqhntqdLevelAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherJlqhntqdLevelArea.png";
            //获取其他结构剪力墙混凝土强度等级图base64
            String otherJlqhntqdLevelArea = ImageUtil.getImageBase(otherJlqhntqdLevelAreaPath);

            //获取其他结构剪力墙最大间距统计图
            String otherJlqzdSpanNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherJlqzdSpanNum.png";
            //获取其他结构剪力墙最大间距图base64
            String otherJlqzdSpanNum = ImageUtil.getImageBase(otherJlqzdSpanNumPath);
            String otherJlqzdSpanAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherJlqzdSpanArea.png";
            //获取其他结构剪力墙最大间距图base64
            String otherJlqzdSpanArea = ImageUtil.getImageBase(otherJlqzdSpanAreaPath);
            /*//获取其他结构剪力墙厚度统计图
            String otherShearwellThicknessPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherShearwellThickness.png";
            //获取其他结构剪力墙厚度图base64
            String otherShearwellThickness = ImageUtil.getImageBase(otherShearwellThicknessPath);*/
            //获取其他结构外墙体材质统计图
            String otherMaterialNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherMaterialNum.png";
            //获取其他结构外墙体材质图base64
            String otherMaterialNum = ImageUtil.getImageBase(otherMaterialNumPath);
            String otherMaterialAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherMaterialArea.png";
            //获取其他结构外墙体材质图base64
            String otherMaterialArea = ImageUtil.getImageBase(otherMaterialAreaPath);

            //获取其他结构外砂浆类型统计图
            String otherMortarTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherMortarTypeNum.png";
            //获取其他结构外砂浆类型图base64
            String otherMortarTypeNum = ImageUtil.getImageBase(otherMortarTypeNumPath);
            String otherMortarTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherMortarTypeArea.png";
            //获取其他结构外砂浆类型图base64
            String otherMortarTypeArea = ImageUtil.getImageBase(otherMortarTypeAreaPath);

            //获取其他结构外楼盖类别统计图
            String otherFloorTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherFloorTypeNum.png";
            //获取其他结构外楼盖类别图base64
            String otherFloorTypeNum = ImageUtil.getImageBase(otherFloorTypeNumPath);
            String otherFloorTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherFloorTypeArea.png";
            //获取其他结构外楼盖类别图base64
            String otherFloorTypeArea = ImageUtil.getImageBase(otherFloorTypeAreaPath);

            //获取其他结构屋盖类型统计图
            String otherRoofTypeNumPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherRoofTypeNum.png";
            //获取其他结构屋盖类型图base64
            String otherRoofTypeNum = ImageUtil.getImageBase(otherRoofTypeNumPath);
            String otherRoofTypeAreaPath = configBeanValue.wordImage + File.separator + timeStamp  + "otherRoofTypeArea.png";
            //获取其他结构屋盖类型图base64
            String otherRoofTypeArea = ImageUtil.getImageBase(otherRoofTypeAreaPath);

            //报告年份
            map.put("year", year);
            //报告月份
            map.put("month", month);
            //报告日
            map.put("day", day);
            //报告人
            map.put("userName", user.getUserName());
            //省份或直辖市
            map.put("province", province);
            //所属市
            if (StringUtils.isEmpty(city)) {
                map.put("city", "");
            } else {
                map.put("city", city);
            }
            //包含的区县
            if (StringUtils.isEmpty(area)) {
                map.put("area", "");
            } else {
                map.put("area", area);
            }
            //起始时间
            map.put("startDate", minTime);
            //结束时间
            map.put("endDate", maxTime);
            //任务总面积
            map.put("taskAreaCount", taskAreaCount);
            map.put("provinceCount", provinceCount);
            map.put("cityCount", cityCount);
            map.put("areaCount", areaCount);
            //总天数
            map.put("countDay", countDay);
            //小组总数
            map.put("groupCount", groupCount);
            //小组列表
            map.put("groupList",groupList);
            //小组成员总数
            map.put("userCount", listGroupUserId.size());
            //最小纬度
            map.put("latitudeSmall", minLatitude);
            //最大纬度
            map.put("latitudeBig", maxLatitude);
            //最小经度
            map.put("longitudeSmall",minLongitude );
            //最大经度
            map.put("longitudeBig",maxLongitude);
            //总栋数
            map.put("countNum", countNum);
            //总面积
            map.put("countArea", countArea);
            //详查工作建筑栋数统计图
            map.put("buildingCountImageNum", buildingCountImageNum);
            //详查工作建筑面积统计图
            map.put("buildingCountImageArea", buildingCountImageArea);
            //详查数据年代统计图-栋数
            map.put("buildingAgeNum", buildingAgeNum);
            //详查数据年代统计图-面积
            map.put("buildingAgeArea", buildingAgeArea);

            //详查数据抗震设防统计图-栋数
            map.put("buildingIntensityNum", buildingIntensityNum);
            //详查数据抗震设防统计图-面积
            map.put("buildingIntensityArea", buildingIntensityArea);
            
            //砖混结构外墙构造-栋数  ${brickMortarStrengthArea}
            map.put("brickOutWallThickNum",brickOutWallThickNum);
            //砖混结构外墙构造-面积
            map.put("brickOutWallThickArea",brickOutWallThickArea);
            //砖混结构内墙构造-栋数
            map.put("brickInWallThickNum",brickInWallThickNum);
            //砖混结构内墙构造-面积
            map.put("brickInWallThickArea",brickInWallThickArea);
            //砖混结构墙体材质-栋数
            map.put("brickWallMaterialNum",brickWallMaterialNum);
            //砖混结构墙体材质-面积
            map.put("brickWallMaterialArea",brickWallMaterialArea);
            //砖混结构砂浆类型-栋数
            map.put("brickMortarTypeNum",brickMortarTypeNum);
            //砖混结构砂浆类型-面积
            map.put("brickMortarTypeArea",brickMortarTypeArea);
            //砖混结构砂浆强度-栋数
            map.put("brickMortarStrengthNum",brickMortarStrengthNum);
            //砖混结构砂浆强度-面积
            map.put("brickMortarStrengthArea",brickMortarStrengthArea);
            //砖混结构屋盖类别-栋数
            map.put("brickRoofTypeNum",brickRoofTypeNum);
            //砖混结构屋盖类别-面积
            map.put("brickRoofTypeArea",brickRoofTypeArea);
            //砖混结构楼盖类别-栋数
            map.put("brickFloorTypeNum",brickFloorTypeNum);
            //砖混结构楼盖类别-面积
            map.put("brickFloorTypeArea",brickFloorTypeArea);
            //砖混结构圈梁设置-栋数
            map.put("brickJlInstallNum",brickJlInstallNum);
            //砖混结构圈梁设置-面积
            map.put("brickJlInstallArea",brickJlInstallArea);

            //砖木结构外墙构造-栋数
            map.put("brickwoodOutWallThickNum",brickwoodOutWallThickNum);
            //砖木结构外墙构造-面积
            map.put("brickwoodOutWallThickArea",brickwoodOutWallThickArea);
            //砖木结构内墙构造-栋数
            map.put("brickwoodInWallThickNum",brickwoodInWallThickNum);
            //砖木结构内墙构造-面积
            map.put("brickwoodInWallThickArea",brickwoodInWallThickArea);
            //砖木结构墙体材质-栋数
            map.put("brickwoodWallMaterialNum",brickwoodWallMaterialNum);
            //砖木结构墙体材质-面积
            map.put("brickwoodWallMaterialArea",brickwoodWallMaterialArea);
            //砖木结构砂浆类型-栋数
            map.put("brickwoodMortarTypeNum",brickwoodMortarTypeNum);
            //砖木结构砂浆类型-面积
            map.put("brickwoodMortarTypeArea",brickwoodMortarTypeArea);
            //砖木结构砂浆强度-栋数
            map.put("brickwoodMortarStrengthNum",brickwoodMortarStrengthNum);
            //砖木结构砂浆强度-面积
            map.put("brickwoodMortarStrengthArea",brickwoodMortarStrengthArea);
            //砖木结构楼盖类别-栋数
            map.put("brickwoodFloorTypeNum",brickwoodFloorTypeNum);
            //砖木结构楼盖类别-面积
            map.put("brickwoodFloorTypeArea",brickwoodFloorTypeArea);

            //多层钢筋混凝土结构柱混凝土强度等级-栋数
            map.put("mulZhntqdLevelNum",mulZhntqdLevelNum);
            //多层钢筋混凝土结构柱混凝土强度等级-面积
            map.put("mulZhntqdLevelArea",mulZhntqdLevelArea);
            //多层钢筋混凝土结构最大柱间距-栋数
            map.put("mulZdzSpanNum",mulZdzSpanNum);
            //多层钢筋混凝土结构最大柱间距-面积
            map.put("mulZdzSpanArea",mulZdzSpanArea);
            //多层钢筋混凝土结构剪力墙混凝土强度等级-栋数
            map.put("mulJlqhntqdLevelNum",mulJlqhntqdLevelNum);
            //多层钢筋混凝土结构剪力墙混凝土强度等级-面积
            map.put("mulJlqhntqdLevelArea",mulJlqhntqdLevelArea);
            //多层钢筋混凝土结构剪力墙最大间距-栋数
            map.put("mulJlqzdSpanNum",mulJlqzdSpanNum);
            //多层钢筋混凝土结构剪力墙最大间距-面积
            map.put("mulJlqzdSpanArea",mulJlqzdSpanArea);
            //多层钢筋混凝土结构剪力墙厚度-栋数
            map.put("mulShearwellThicknessNum",mulShearwellThicknessNum);
            //多层钢筋混凝土结构剪力墙厚度-面积
            map.put("mulShearwellThicknessArea",mulShearwellThicknessArea);
            //多层钢筋混凝土结构屋盖类别-栋数
            map.put("mulRoofTypeNum",mulRoofTypeNum);
            //多层钢筋混凝土结构屋盖类别-面积
            map.put("mulRoofTypeArea",mulRoofTypeArea);
            //多层钢筋混凝土结构楼盖类别-栋数
            map.put("mulFloorTypeNum",mulFloorTypeNum);
            //多层钢筋混凝土结构楼盖类别-面积
            map.put("mulFloorTypeArea",mulFloorTypeArea);

            //高层结构柱混凝土强度等级-栋数
            map.put("heightZhntqdLevelNum",heightZhntqdLevelNum);
            //高层结构柱混凝土强度等级-面积
            map.put("heightZhntqdLevelArea",heightZhntqdLevelArea);
            //高层结构最大柱间距-栋数
            map.put("heightZdzSpanNum",heightZdzSpanNum);
            //高层结构最大柱间距-面积
            map.put("heightZdzSpanArea",heightZdzSpanArea);
            //高层结构剪力墙混凝土强度等级-栋数
            map.put("heightJlqhntqdLevelNum",heightJlqhntqdLevelNum);
            //高层结构剪力墙混凝土强度等级-面积
            map.put("heightJlqhntqdLevelArea",heightJlqhntqdLevelArea);
            //高层结构剪力墙最大间距-栋数
            map.put("heightJlqzdSpanNum",heightJlqzdSpanNum);
            //高层结构剪力墙最大间距-面积
            map.put("heightJlqzdSpanArea",heightJlqzdSpanArea);
            //高层结构剪力墙厚度-栋数
            map.put("heightShearwellThicknessNum",heightShearwellThicknessNum);
            //高层结构剪力墙厚度-面积
            map.put("heightShearwellThicknessArea",heightShearwellThicknessArea);
            //高层结构剪力墙屋盖类别-栋数
            map.put("heightRoofTypeNum",heightRoofTypeNum);
            //高层结构剪力墙屋盖类别-面积
            map.put("heightRoofTypeArea",heightRoofTypeArea);
            //高层结构剪力墙楼盖类别-栋数
            map.put("heightFloorTypeNum",heightFloorTypeNum);
            //高层结构剪力墙楼盖类别-面积
            map.put("heightFloorTypeArea",heightFloorTypeArea);

            //工业厂房结构排架柱类型-栋数
            map.put("factoryBentFrameColTypeNum",factoryBentFrameColTypeNum);
            //工业厂房结构排架柱类型-面积
            map.put("factoryBentFrameColTypeArea",factoryBentFrameColTypeArea);
            //工业厂房结构各跨跨度-栋数
            map.put("factorySpansNum",factorySpansNum);
            //工业厂房结构各跨跨度-面积
            map.put("factorySpansArea",factorySpansArea);
            //工业厂房结构排架柱距-栋数
            map.put("factoryBentFrameColSpaceNum",factoryBentFrameColSpaceNum);
            //工业厂房结构排架柱距-面积
            map.put("factoryBentFrameColSpaceArea",factoryBentFrameColSpaceArea);
            //工业厂房结构屋盖体系-栋数
            map.put("factoryRoofSystemNum",factoryRoofSystemNum);
            //工业厂房结构屋盖体系-面积
            map.put("factoryRoofSystemArea",factoryRoofSystemArea);
            //工业厂房结构屋架形式-栋数
            map.put("factoryRoofTrussStyleNum",factoryRoofTrussStyleNum);
            //工业厂房结构屋架形式-面积
            map.put("factoryRoofTrussStyleArea",factoryRoofTrussStyleArea);
            //工业厂房结构圈梁道数-栋数
            map.put("factoryRingBeamNumNum",factoryRingBeamNumNum);
            //工业厂房结构圈梁道数-面积
            map.put("factoryRingBeamNumArea",factoryRingBeamNumArea);

            //空旷结构柱类型-栋数
            map.put("wideColTypePieNum",wideColTypePieNum);
            //空旷结构柱类型-面积
            map.put("wideColTypePieArea",wideColTypePieArea);
            //空旷结构柱跨度-栋数
            map.put("wideColSpanNum",wideColSpanNum);
            //空旷结构柱跨度-面积
            map.put("wideColSpanArea",wideColSpanArea);
            //空旷结构柱距-栋数
            map.put("wideColSpaceNum",wideColSpaceNum);
            //空旷结构柱距-面积
            map.put("wideColSpaceArea",wideColSpaceArea);
            //空旷结构屋面类别-栋数
            map.put("wideWmTypeNum",wideWmTypeNum);
            //空旷结构屋面类别-面积
            map.put("wideWmTypeArea",wideWmTypeArea);
            //空旷结构屋架形式-栋数
            map.put("wideWjGenreNum",wideWjGenreNum);
            //空旷结构屋架形式-面积
            map.put("wideWjGenreArea",wideWjGenreArea);
            //空旷结构圈梁道数-栋数
            map.put("wideRingBeamNum",wideRingBeamNum);
            //空旷结构圈梁道数-面积
            map.put("wideRingBeamArea",wideRingBeamArea);

            //土木结构墙体类型-栋数
            map.put("buildingQtyxclNum",buildingQtyxclNum);
            //土木结构墙体类型-面积
            map.put("buildingQtyxclArea",buildingQtyxclArea);
            //土木结构墙体延性材料-栋数
            map.put("buildingWallTypeNum",buildingWallTypeNum);
            //土木结构墙体延性材料-面积
            map.put("buildingWallTypeArea",buildingWallTypeArea);
            //土木结构墙体厚度-栋数
            map.put("buildingWallThickNum",buildingWallThickNum);
            //土木结构墙体厚度-面积
            map.put("buildingWallThickArea",buildingWallThickArea);
            //土木结构门窗洞口宽度-栋数
            map.put("buildingWindowWidthNum",buildingWindowWidthNum);
            //土木结构门窗洞口宽度-面积
            map.put("buildingWindowWidthArea",buildingWindowWidthArea);
            //土木结构屋架材料-栋数
            map.put("buildingWmMaterialNum",buildingWmMaterialNum);
            //土木结构屋架材料-面积
            map.put("buildingWmMaterialArea",buildingWmMaterialArea);
            //土木结构墙体圈梁-栋数
            map.put("buildingWallRingBeamNum",buildingWallRingBeamNum);
            //土木结构墙体圈梁-面积
            map.put("buildingWallRingBeamArea",buildingWallRingBeamArea);

            //木结构穿斗方式-栋数
            map.put("woodCdTypeNum",woodCdTypeNum);
            //木结构穿斗方式-面积
            map.put("woodCdTypeArea",woodCdTypeArea);
            //木结构木柱梢径-栋数
            map.put("woodMzsjNum",woodMzsjNum);
            //木结构木柱梢径-面积
            map.put("woodMzsjArea",woodMzsjArea);
            //木结构围护墙体类型-栋数
            map.put("woodWallTypeNum",woodWallTypeNum);
            //木结构围护墙体类型-面积
            map.put("woodWallTypeArea",woodWallTypeArea);
            //木结构山尖墙体类型-栋数
            map.put("woodSjqtTypeNum",woodSjqtTypeNum);
            //木结构山尖墙体类型-面积
            map.put("woodSjqtTypeArea",woodSjqtTypeArea);
            //木结构墙体厚度-栋数
            map.put("woodWallThickNum",woodWallThickNum);
            //木结构墙体厚度-面积
            map.put("woodWallThickArea",woodWallThickArea);
            //木结构墙体圈梁-栋数
            map.put("woodWallRingBeamNum",woodWallRingBeamNum);
            //木结构墙体圈梁-面积
            map.put("woodWallRingBeamArea",woodWallRingBeamArea);

            //石木结构墙体材质-栋数
            map.put("stoneWallMaterialNum",stoneWallMaterialNum);
            //石木结构墙体材质-面积
            map.put("stoneWallMaterialArea",stoneWallMaterialArea);
            //石木结构横墙最大间距-栋数
            map.put("stoneHqzdSpaceNum",stoneHqzdSpaceNum);
            //石木结构横墙最大间距-面积
            map.put("stoneHqzdSpaceArea",stoneHqzdSpaceArea);
            //石木结构墙体厚度-栋数
            map.put("stoneWallThickNum",stoneWallThickNum);
            //石木结构墙体厚度-面积
            map.put("stoneWallThickArea",stoneWallThickArea);
            //石木结构横墙开洞面积-栋数
            map.put("stoneHqkdAreaNum",stoneHqkdAreaNum);
            //石木结构横墙开洞面积-面积
            map.put("stoneHqkdAreaArea",stoneHqkdAreaArea);
            //石木结构屋盖类型-栋数
            map.put("stoneRoofTypeNum",stoneRoofTypeNum);
            //石木结构屋盖类型-面积
            map.put("stoneRoofTypeArea",stoneRoofTypeArea);
            //石木结构圈梁-栋数
            map.put("stoneQlNum",stoneQlNum);
            //石木结构圈梁-面积
            map.put("stoneQlArea",stoneQlArea);
            //石木结构四角设构造-栋数
            map.put("stoneSjsgzzNum",stoneSjsgzzNum);
            //石木结构四角设构造-面积
            map.put("stoneSjsgzzArea",stoneSjsgzzArea);

            //其他结构
            //获取其他结构剪力墙混凝土强度等级统计图-栋数
            map.put("otherJlqhntqdLevelNum",otherJlqhntqdLevelNum);
            //获取其他结构剪力墙混凝土强度等级统计图-面积
            map.put("otherJlqhntqdLevelArea",otherJlqhntqdLevelArea);
            //获取其他结构剪力墙最大间距统计图-栋数
            map.put("otherJlqzdSpanNum",otherJlqzdSpanNum);
            //获取其他结构剪力墙最大间距统计图-面积
            map.put("otherJlqzdSpanArea",otherJlqzdSpanArea);
            //获取其他结构外砂浆类型统计图-栋数
            map.put("otherMortarTypeNum",otherMortarTypeNum);
            //获取其他结构外砂浆类型统计图-面积
            map.put("otherMortarTypeArea",otherMortarTypeArea);
            //获取其他结构外墙体材质统计图-栋数
            map.put("otherMaterialNum",otherMaterialNum);
            //获取其他结构外墙体材质统计图-面积
            map.put("otherMaterialArea",otherMaterialArea);
            //获取其他结构外楼盖类别统计图-栋数
            map.put("otherFloorTypeNum",otherFloorTypeNum);
            //获取其他结构外楼盖类别统计图-面积
            map.put("otherFloorTypeArea",otherFloorTypeArea);
            //获取其他结构屋盖类型统计图-栋数
            map.put("otherRoofTypeNum",otherRoofTypeNum);
            //获取其他结构屋盖类型统计图-面积
            map.put("otherRoofTypeArea",otherRoofTypeArea);

            //砖混总数
            map.put("brickStructureNum", brickStructureNum);
            //砖混数量占比
            if (StringUtils.isEmpty(brickStructureAreaProportion)) {
                map.put("brickStructureNumProportion", "0.00%");
            } else {
                //砖混数量占比
                map.put("brickStructureNumProportion", brickStructureNumProportion);
            }
            //砖混总面积
            map.put("brickStructureArea", brickStructureArea);
            //砖混总面积占比
            if (StringUtils.isEmpty(brickStructureAreaProportion)) {
                map.put("brickStructureAreaProportion", "0.00%");
            } else {
                //砖混总面积占比
                map.put("brickStructureAreaProportion", brickStructureAreaProportion);
            }
            //砖木总数
            map.put("brickwoodStructureNum", brickwoodStructureNum);
            //砖木数量占比
            if (StringUtils.isEmpty(brickwoodStructureNumProportion)) {
                map.put("brickwoodStructureNumProportion", "0.00%");
            } else {
                //砖木数量占比
                map.put("brickwoodStructureNumProportion", brickwoodStructureNumProportion);
            }
            //砖木总面积
            map.put("brickwoodStructureArea", brickwoodStructureArea);
            //砖木总面积占比
            if (StringUtils.isEmpty(brickwoodStructureAreaProportion)) {
                map.put("brickwoodStructureAreaProportion", "0.00%");
            } else {
                //砖木总面积占比
                map.put("brickwoodStructureAreaProportion", brickwoodStructureAreaProportion);
            }
            //土木结构总数
            map.put("buildingStructureNum", buildingStructureNum);
            //土木结构总数占比 buildingStructureNumProportion
            if (StringUtils.isEmpty(buildingStructureNumProportion)) {
                map.put("buildingStructureNumProportion", "0.00%");
            } else {
                //土木结构总数占比
                map.put("buildingStructureNumProportion", buildingStructureNumProportion);
            }
            //土木总面积总数
            map.put("buildingStructureArea", buildingStructureArea);
            if (StringUtils.isEmpty(buildingStructureAreaProportion)) {
                map.put("buildingStructureAreaProportion", "0.00%");
            } else {
                //土木总面积占比
                map.put("buildingStructureAreaProportion", buildingStructureAreaProportion);
            }
            //工厂结构数量总数
            map.put("factoryStructureNum", factoryStructureNum);
            //工厂结构数量占比
            if (StringUtils.isEmpty(factoryStructureNumProportion)) {
                map.put("factoryStructureNumProportion", "0.00%");
            } else {
                map.put("factoryStructureNumProportion", factoryStructureNumProportion);
            }
            //工厂结构面积总数
            map.put("factoryStructureArea", factoryStructureArea);
            //工厂结构面积占比
            if (StringUtils.isEmpty(factoryStructureAreaProportion)) {
                map.put("factoryStructureAreaProportion", "0.00%");
            } else {
                map.put("factoryStructureAreaProportion", factoryStructureAreaProportion);
            }
            //高层结构数量总数
            map.put("highStructureNum", highStructureNum);
            //高层结构数量占比
            if (StringUtils.isEmpty(highStructureNumProportion)) {
                map.put("highStructureNumProportion", "0.00%");
            } else {
                map.put("highStructureNumProportion", highStructureNumProportion);
            }
            //高层结构面积总数
            map.put("highStructureArea", highStructureArea);
            //高层结构面积占比
            if (StringUtils.isEmpty(highStructureAreaProportion)) {
                map.put("highStructureAreaProportion", "0.00%");
            } else {
                map.put("highStructureAreaProportion", highStructureAreaProportion);
            }
            //多层钢筋混凝土数量总数
            map.put("mulConcreteStructureNum", mulConcreteStructureNum);
            //多层钢筋混凝土数量占比
            if (StringUtils.isEmpty(mulConcreteStructureNumProportion)) {
                map.put("mulConcreteStructureNumProportion", "0.00%");
            } else {
                map.put("mulConcreteStructureNumProportion", mulConcreteStructureNumProportion);
            }
            //多层钢筋混凝土面积总数
            map.put("mulConcreteStructureArea", mulConcreteStructureArea);
            //多层钢筋混凝土面积总数占比
            if (StringUtils.isEmpty(mulConcreteStructureAreaProportion)) {
                map.put("mulConcreteStructureAreaProportion", "0.00%");
            } else {
                map.put("mulConcreteStructureAreaProportion", mulConcreteStructureAreaProportion);
            }
            //石结构建筑总数
            map.put("stoneStructureNum", stoneStructureNum);
            //石结构建筑总数占比
            if (StringUtils.isEmpty(stoneStructureNumProportion)) {
                map.put("stoneStructureNumProportion", "0.00%");
            } else {
                map.put("stoneStructureNumProportion", stoneStructureNumProportion);
            }
            //石结构面积总数
            map.put("stoneStructureArea", stoneStructureArea);
            //石结构面积总数占比
            if (StringUtils.isEmpty(stoneStructureAreaProportion)) {
                map.put("stoneStructureAreaProportion", "0.00%");
            } else {
                map.put("stoneStructureAreaProportion", stoneStructureAreaProportion);
            }
            //空旷结构数量总数
            map.put("wideStructureNum", wideStructureNum);
            //空旷结构总数占比
            if (StringUtils.isEmpty(wideStructureNumProportion)) {
                map.put("wideStructureNumProportion", "0.00%");
            } else {
                map.put("wideStructureNumProportion", wideStructureNumProportion);
            }
            //空旷结构面积总数
            map.put("wideStructureArea", wideStructureArea);
            //空旷结构面积总数占比
            if (StringUtils.isEmpty(wideStructureAreaProportion)) {
                map.put("wideStructureAreaProportion", "0.00%");
            } else {
                map.put("wideStructureAreaProportion", wideStructureAreaProportion);
            }
            //木结构数量总数
            map.put("woodStructureNum", woodStructureNum);
            //木结构总数占比
            if (StringUtils.isEmpty(woodStructureNumProportion)) {
                map.put("woodStructureNumProportion", "0.00%");
            } else {
                map.put("woodStructureNumProportion", woodStructureNumProportion);
            }
            //木结构面积总数
            map.put("woodStructureArea", woodStructureArea);
            //木结构面积总数占比
            if (StringUtils.isEmpty(woodStructureAreaProportion)) {
                map.put("woodStructureAreaProportion", "0.00%");
            } else {
                map.put("woodStructureAreaProportion", woodStructureAreaProportion);
            }
            //otherStructureNum
            //其他结构数量总数
            map.put("otherStructureNum", otherStructureNum);
            //其他结构总数占比
            if (StringUtils.isEmpty(otherStructureNumProportion)) {
                map.put("otherStructureNumProportion", "0.00%");
            } else {
                map.put("otherStructureNumProportion", otherStructureNumProportion);
            }
            //其他结构面积总数
            map.put("otherStructureArea", otherStructureArea);
            //其他结构面积总数占比
            if (StringUtils.isEmpty(otherStructureAreaProportion)) {
                map.put("otherStructureAreaProportion", "0.00%");
            } else {
                map.put("otherStructureAreaProportion", otherStructureAreaProportion);
            }
            //附件的总大小
            map.put("size", size);
            //砖混栋数抽样率
            if (StringUtils.isEmpty(brickNumProportion)) {
                map.put("brickNumProportion", "0.00%");
            } else {
                map.put("brickNumProportion", brickNumProportion);
            }
            //砖混面积抽样率
            if (StringUtils.isEmpty(brickAreaProportion)) {
                map.put("brickAreaProportion", "0.00%");
            } else {
                map.put("brickAreaProportion", brickAreaProportion);
            }
            //砖木栋数抽样率
            if (StringUtils.isEmpty(brickwoodNumProportion)) {
                map.put("brickwoodNumProportion", "0.00%");
            } else {
                map.put("brickwoodNumProportion", brickwoodNumProportion);
            }
            //砖木面积抽样率
            if (StringUtils.isEmpty(brickwoodAreaProportion)) {
                map.put("brickwoodAreaProportion", "0.00%");
            } else {
                map.put("brickwoodAreaProportion", brickwoodAreaProportion);
            }
            //多层钢结构混凝土结构数量抽样率
            if (StringUtils.isEmpty(mulConcreteStructureNumXCProportion)) {
                map.put("mulConcreteStructureNumXCProportion", "0.00%");
            } else {
                map.put("mulConcreteStructureNumXCProportion", mulConcreteStructureNumXCProportion);
            }
            //多层钢结构混凝土结构面积抽样率
            if (StringUtils.isEmpty(mulConcreteStructureAreaXCProportion)) {
                map.put("mulConcreteStructureAreaXCProportion", "0.00%");
            } else {
                map.put("mulConcreteStructureAreaXCProportion", mulConcreteStructureAreaXCProportion);
            }
            //高层结构栋数抽样率
            if (StringUtils.isEmpty(highStructureNumXCProportion)) {
                map.put("highStructureNumXCProportion", "0.00%");
            } else {
                map.put("highStructureNumXCProportion", highStructureNumXCProportion);
            }
            //高层结构面积抽样率
            if (StringUtils.isEmpty(highStructureAreaXCProportion)) {
                map.put("highStructureAreaXCProportion", "0.00%");
            } else {
                map.put("highStructureAreaXCProportion", highStructureAreaXCProportion);
            }
            //工厂结构栋数抽样率
            if (StringUtils.isEmpty(factoryStructureNumXCProportion)) {
                map.put("factoryStructureNumXCProportion", "0.00%");
            } else {
                map.put("factoryStructureNumXCProportion", factoryStructureNumXCProportion);
            }
            //工厂结构面积抽样率
            if (StringUtils.isEmpty(factoryStructureAreaXCProportion)) {
                map.put("factoryStructureAreaXCProportion", "0.00%");
            } else {
                map.put("factoryStructureAreaXCProportion", factoryStructureAreaXCProportion);
            }
            //空旷结构数量抽样率
            if (StringUtils.isEmpty(wideStructureNumXCProportion)) {
                map.put("wideStructureNumXCProportion", "0.00%");
            } else {
                map.put("wideStructureNumXCProportion", wideStructureNumXCProportion);
            }
            //空旷结构面积抽样率
            if (StringUtils.isEmpty(wideStructureAreaXCProportion)) {
                map.put("wideStructureAreaXCProportion", "0.00%");
            } else {
                map.put("wideStructureAreaXCProportion", wideStructureAreaXCProportion);
            }
            //土木结构数量抽样率
            if (StringUtils.isEmpty(buildingStructureNumXCProportion)) {
                map.put("buildingStructureNumXCProportion", "0.00%");
            } else {
                map.put("buildingStructureNumXCProportion", buildingStructureNumXCProportion);
            }
            //土木结构面积抽样率
            if (StringUtils.isEmpty(buildingStructureAreaXCProportion)) {
                map.put("buildingStructureAreaXCProportion", "0.00%");
            } else {
                map.put("buildingStructureAreaXCProportion", buildingStructureAreaXCProportion);
            }
            //木结构数量抽样率
            if (StringUtils.isEmpty(woodStructureNumXCProportion)) {
                map.put("woodStructureNumXCProportion", "0.00%");
            } else {
                map.put("woodStructureNumXCProportion", woodStructureNumXCProportion);
            }
            //木结构面积抽样率
            if (StringUtils.isEmpty(woodStructureAreaXCProportion)) {
                map.put("woodStructureAreaXCProportion", "0.00%");
            } else {
                map.put("woodStructureAreaXCProportion", woodStructureAreaXCProportion);
            }
            //石结构数量抽样率
            if (StringUtils.isEmpty(stoneStructureNumXCProportion)) {
                map.put("stoneStructureNumXCProportion", "0.00%");
            } else {
                map.put("stoneStructureNumXCProportion", stoneStructureNumXCProportion);
            }
            //石结构面积抽样率
            if (StringUtils.isEmpty(stoneStructureAreaXCProportion)) {
                map.put("stoneStructureAreaXCProportion", "0.00%");
            } else {
                map.put("stoneStructureAreaXCProportion", stoneStructureAreaXCProportion);
            }
            //
            //其他结构数量抽样率
            if (StringUtils.isEmpty(otherStructureAreaXCProportion)) {
                map.put("otherStructureNumXCProportion", "0.00%");
            } else {
                map.put("otherStructureNumXCProportion", otherStructureNumXCProportion);
            }
            //其他结构面积抽样率
            if (StringUtils.isEmpty(otherStructureAreaXCProportion)) {
                map.put("otherStructureAreaXCProportion", "0.00%");
            } else {
                map.put("otherStructureAreaXCProportion", otherStructureAreaXCProportion);
            }

            //城镇建筑砖混数量
            map.put("cityTaskBrickCount", cityTaskBrickCount + noCityTaskBrickCount);
            //城镇建筑砖混数量占比
            if (StringUtils.isEmpty(cityBrickNumProportion)) {
                map.put("cityBrickNumProportion", "0.00%");
            } else {
                map.put("cityBrickNumProportion", cityBrickNumProportion);
            }
            //城镇建筑砖混面积
            map.put("cityTaskBrickArea", cityTaskBrickArea + noCityTaskBrickArea);
            //城镇建筑砖混面积占比
            if (StringUtils.isEmpty(cityBrickAreaProportion)) {
                map.put("cityBrickAreaProportion", "0.00%");
            } else {
                map.put("cityBrickAreaProportion", cityBrickAreaProportion);
            }
            //城镇建筑底层混凝土柱-上部砖混数量
            map.put("cityTaskTopBrickCount", cityTaskTopBrickCount + noCityTaskTopBrickCount);
            //城镇建筑底层混凝土柱-上部砖混数量占比
            if (StringUtils.isEmpty(cityTopBrickNumProportion)) {
                map.put("cityTopBrickNumProportion", "0.00%");
            } else {
                map.put("cityTopBrickNumProportion", cityTopBrickNumProportion);
            }
            //城镇建筑底层混凝土柱-上部砖混面积
            map.put("cityTaskTopBrickArea", cityTaskTopBrickArea + noCityTaskTopBrickArea);
            //城镇建筑底层混凝土柱-上部砖混面积占比
            if (StringUtils.isEmpty(cityTopBrickAreaProportion)) {
                map.put("cityTopBrickAreaProportion", "0.00%");
            } else {
                map.put("cityTopBrickAreaProportion", cityTopBrickAreaProportion);
            }
            //钢筋混凝土数量
            map.put("cityTaskReinforcedConcreteCount", cityTaskReinforcedConcreteCount + noCityTaskReinforcedConcreteCount);
            //钢筋混凝土数量占比
            if (StringUtils.isEmpty(cityReinforcedConcreteNumProportion)) {
                map.put("cityReinforcedConcreteNumProportion", "0.00%");
            } else {
                map.put("cityReinforcedConcreteNumProportion", cityReinforcedConcreteNumProportion);
            }
            //钢筋混凝土面积
            map.put("cityTaskReinforcedConcreteArea", cityTaskReinforcedConcreteArea + noCityTaskReinforcedConcreteArea);
            //钢筋混凝土面积占比
            if (StringUtils.isEmpty(cityReinforcedConcreteAreaProportion)) {
                map.put("cityReinforcedConcreteAreaProportion", "0.00%");
            } else {
                map.put("cityReinforcedConcreteAreaProportion", cityReinforcedConcreteAreaProportion);
            }
            //砖木数量
            map.put("cityTaskBrickWoodCount", cityTaskBrickWoodCount + noCityTaskBrickWoodCount);
            //砖木数量占比
            if (StringUtils.isEmpty(cityBrickWoodNumProportion)) {
                map.put("cityBrickWoodNumProportion", "0.00%");
            } else {
                map.put("cityBrickWoodNumProportion", cityBrickWoodNumProportion);
            }
            //砖木面积
            map.put("cityTaskBrickWoodArea", cityTaskBrickWoodArea + noCityTaskBrickWoodArea);
            //砖木面积占比
            if (StringUtils.isEmpty(cityBrickWoodAreaProportion)) {
                map.put("cityBrickWoodAreaProportion", "0.00%");
            } else {
                map.put("cityBrickWoodAreaProportion", cityBrickWoodAreaProportion);
            }
            //钢结构数量
            map.put("cityTaskSteelStructureCount", cityTaskSteelStructureCount + noCityTaskSteelStructureCount);
            //钢结构数量占比
            if (StringUtils.isEmpty(cityBrickWoodAreaProportion)) {
                map.put("citySteelStructureNumProportion", "0.00%");
            } else {
                map.put("citySteelStructureNumProportion", citySteelStructureNumProportion);
            }
            //钢结构面积
            map.put("cityTaskSteelStructureArea", cityTaskSteelStructureArea + noCityTaskSteelStructureArea);
            //钢结构面积占比
            if (StringUtils.isEmpty(citySteelStructureAreaProportion)) {
                map.put("citySteelStructureAreaProportion", "0.00%");
            } else {
                map.put("citySteelStructureAreaProportion", citySteelStructureAreaProportion);
            }
            //木结构数量
            map.put("cityTaskWoodStructureCount", cityTaskWoodStructureCount + noCityTaskWoodStructureCount);
            //木结构数量占比
            if (StringUtils.isEmpty(cityBrickWoodNumProportion)) {
                map.put("cityBrickWoodNumProportion", "0.00%");
            } else {
                map.put("cityBrickWoodNumProportion", cityBrickWoodNumProportion);
            }
            //木结构面积
            map.put("cityTaskWoodStructureArea", cityTaskWoodStructureArea + noCityTaskWoodStructureArea);
            //木结构面积占比
            if (StringUtils.isEmpty(cityBrickWoodAreaProportion)) {
                map.put("cityBrickWoodAreaProportion", "0.00%");
            } else {
                map.put("cityBrickWoodAreaProportion", cityBrickWoodAreaProportion);
            }
            //其他数量
            map.put("cityTaskOtherCount", cityTaskOtherCount + noCityTaskOtherCount);
            //其数量占比
            if (StringUtils.isEmpty(cityOtherNumProportion)) {
                map.put("cityOtherNumProportion", "0.00%");
            } else {
                map.put("cityOtherNumProportion", cityOtherNumProportion);
            }
            //其他数量
            map.put("cityTaskOtherArea", cityTaskOtherArea + noCityTaskOtherArea);
            //其数量占比
            if (StringUtils.isEmpty(cityOtherAreaProportion)) {
                map.put("cityOtherAreaProportion", "0.00%");
            } else {
                map.put("cityOtherAreaProportion", cityOtherAreaProportion);
            }
            //农村砖（砌块）混数量
            map.put("villageHouseBrickCount", villageHouseBrickCount + villagePubHouseBrickCount);
            //农村砖（砌块）混数量占比
            if (StringUtils.isEmpty(villageBrickNumProportion)) {
                map.put("villageBrickNumProportion", "0.00%");
            } else {
                map.put("villageBrickNumProportion", villageBrickNumProportion);
            }
            //农村砖（砌块）混面积
            map.put("villageHouseBrickArea", villageHouseBrickArea + villagePubHouseBrickArea);
            //农村砖（砌块）混面积占比
            if (StringUtils.isEmpty(villageBrickAreaProportion)) {
                map.put("villageBrickAreaProportion", "0.00%");
            } else {
                map.put("villageBrickAreaProportion", villageBrickAreaProportion);
            }
            //农村低层框架数量
            map.put("villageHouseLowerFrameCount", villageHouseLowerFrameCount + villagePubHouseLowerFrameCount);
            //农村低层框架数量占比
            if (StringUtils.isEmpty(villageLowerFrameNumProportion)) {
                map.put("villageLowerFrameNumProportion", "0.00%");
            } else {
                map.put("villageLowerFrameNumProportion", villageLowerFrameNumProportion);
            }
            //农村低层框架面积
            map.put("villageHouseLowerFrameArea", villageHouseLowerFrameArea + villagePubHouseLowerFrameArea);
            //农村低层框架面积占比
            if (StringUtils.isEmpty(villageLowerFrameAreaProportion)) {
                map.put("villageLowerFrameAreaProportion", "0.00%");
            } else {
                map.put("villageLowerFrameAreaProportion", villageLowerFrameAreaProportion);
            }
            //农村轻钢（钢）装配式数量
            map.put("villageHouseSteelAssemblyCount", villageHouseSteelAssemblyCount + villagePubHouseSteelAssemblyCount);
            //农村轻钢（钢）装配式数量占比
            if (StringUtils.isEmpty(villageSteelAssemblyNumProportion)) {
                map.put("villageSteelAssemblyNumProportion", "0.00%");
            } else {
                map.put("villageSteelAssemblyNumProportion", villageSteelAssemblyNumProportion);
            }
            //农村轻钢（钢）装配式面积
            map.put("villageHouseSteelAssemblyArea", villageHouseSteelAssemblyArea + villagePubHouseSteelAssemblyArea);
            //农村轻钢（钢）装配式面积占比
            if (StringUtils.isEmpty(villageSteelAssemblyAreaProportion)) {
                map.put("villageSteelAssemblyAreaProportion", "0.00%");
            } else {
                map.put("villageSteelAssemblyAreaProportion", villageSteelAssemblyAreaProportion);
            }
            //农村混凝土装配式数量
            map.put("villageHouseConcreteAssemblyCount", villageHouseConcreteAssemblyCount + villagePubHouseConcreteAssemblyCount);
            //农村混凝土装配式数量占比
            if (StringUtils.isEmpty(villageConcreteAssemblyNumProportion)) {
                map.put("villageConcreteAssemblyNumProportion", "0.00%");
            } else {
                map.put("villageConcreteAssemblyNumProportion", villageConcreteAssemblyNumProportion);
            }
            //农村混凝土装配式面积
            map.put("villageHouseConcreteAssemblyArea", villageHouseConcreteAssemblyArea + villagePubHouseConcreteAssemblyArea);
            //农村混凝土装配式面积占比
            if (StringUtils.isEmpty(villageConcreteAssemblyAreaProportion)) {
                map.put("villageConcreteAssemblyAreaProportion", "0.00%");
            } else {
                map.put("villageConcreteAssemblyAreaProportion", villageConcreteAssemblyAreaProportion);
            }
            //农村砖木数量
            map.put("villageHouseBrickWoodCount", villageHouseBrickWoodCount + villagePubHouseBrickWoodCount);
            //农村砖木数量占比
            if (StringUtils.isEmpty(villageBrickWoodNumProportion)) {
                map.put("villageBrickWoodNumProportion", "0.00%");
            } else {
                map.put("villageBrickWoodNumProportion", villageBrickWoodNumProportion);
            }
            //农村砖木面积
            map.put("villageHouseBrickWoodArea", villageHouseBrickWoodArea + villagePubHouseBrickWoodArea);
            //农村砖木面积占比
            if (StringUtils.isEmpty(villageBrickWoodAreaProportion)) {
                map.put("villageBrickWoodAreaProportion", "0.00%");
            } else {
                map.put("villageBrickWoodAreaProportion", villageBrickWoodAreaProportion);
            }
            //农村土木数量
            map.put("villageHouseCivilWoodCount", villageHouseCivilWoodCount + villagePubHouseCivilWoodCount);
            //农村土木数量占比
            if (StringUtils.isEmpty(villageCivilWoodNumProportion)) {
                map.put("villageCivilWoodNumProportion", "0.00%");
            } else {
                map.put("villageCivilWoodNumProportion", villageCivilWoodNumProportion);
            }
            //农村土木面积
            map.put("villageHouseCivilWoodArea", villageHouseCivilWoodArea + villagePubHouseCivilWoodArea);
            //农村土木面积占比
            if (StringUtils.isEmpty(villageCivilWoodAreaProportion)) {
                map.put("villageCivilWoodAreaProportion", "0.00%");
            } else {
                map.put("villageCivilWoodAreaProportion", villageCivilWoodAreaProportion);
            }
            //农村石木数量
            map.put("villageHouseStoneWoodCount", villageHouseStoneWoodCount + villagePubHouseStoneWoodCount);
            //农村石木数量占比
            if (StringUtils.isEmpty(villageStoneWoodAreaProportion)) {
                map.put("villageStoneWoodAreaProportion", "0.00%");
            } else {
                map.put("villageStoneWoodAreaProportion", villageStoneWoodAreaProportion);
            }
            //农村石木面积
            map.put("villageHouseStoneWoodArea", villageHouseStoneWoodArea + villagePubHouseStoneWoodArea);
            //农村石木面积占比
            if (StringUtils.isEmpty(villageStoneWoodAreaProportion)) {
                map.put("villageStoneWoodAreaProportion", "0.00%");
            } else {
                map.put("villageStoneWoodAreaProportion", villageStoneWoodAreaProportion);
            }
            //农村木结构数量
            map.put("villageHouseWoodStructureCount", villageHouseWoodStructureCount + villagePubHouseWoodStructureCount);
            //农村木结构数量占比
            if (StringUtils.isEmpty(villageWoodStructureNumProportion)) {
                map.put("villageWoodStructureNumProportion", "0.00%");
            } else {
                map.put("villageWoodStructureNumProportion", villageWoodStructureNumProportion);
            }
            //农村木结构面积
            map.put("villageHouseWoodStructureArea", villageHouseWoodStructureArea + villageHouseWoodStructureArea);
            //农村木结构面积占比
            if (StringUtils.isEmpty(villageWoodStructureAreaProportion)) {
                map.put("villageWoodStructureAreaProportion", "0.00%");
            } else {
                map.put("villageWoodStructureAreaProportion", villageWoodStructureAreaProportion);
            }
            //农村窑洞数量
            map.put("villageHouseCaveDwellingCount", villageHouseCaveDwellingCount + villagePubHouseCaveDwellingCount);
            //农村窑洞数量占比
            if (StringUtils.isEmpty(villageCaveDwellingNumProportion)) {
                map.put("villageCaveDwellingNumProportion", "0.00%");
            } else {
                map.put("villageCaveDwellingNumProportion", villageCaveDwellingNumProportion);
            }
            //农村窑洞面积
            map.put("villageHouseCaveDwellingArea", villageHouseCaveDwellingArea + villagePubHouseCaveDwellingArea);
            //农村窑洞面积占比
            if (StringUtils.isEmpty(villageCaveDwellingAreaProportion)) {
                map.put("villageCaveDwellingAreaProportion", "0.00%");
            } else {
                map.put("villageCaveDwellingAreaProportion", villageCaveDwellingAreaProportion);
            }
            //农村混杂结构（砖/砌块/土/石）数量
            map.put("villageHouseMixedStructureCount", villageHouseMixedStructureCount + villagePubHouseMixedStructureCount);
            //农村混杂结构（砖/砌块/土/石）数量占比
            if (StringUtils.isEmpty(villageMixedStructureNumProportion)) {
                map.put("villageMixedStructureNumProportion", "0.00%");
            } else {
                map.put("villageMixedStructureNumProportion", villageMixedStructureNumProportion);
            }
            //农村混杂结构（砖/砌块/土/石）面积
            map.put("villageHouseMixedStructureArea", villageHouseMixedStructureArea + villagePubHouseMixedStructureArea);
            //农村混杂结构（砖/砌块/土/石）面积占比
            if (StringUtils.isEmpty(villageMixedStructureAreaProportion)) {
                map.put("villageMixedStructureAreaProportion", "0.00%");
            } else {
                map.put("villageMixedStructureAreaProportion", villageMixedStructureAreaProportion);
            }
            //农村其他数量
            map.put("villageHouseOtherCount", villageHouseOtherCount + villagePubHouseOtherCount);
            //农村其他数量占比
            if (StringUtils.isEmpty(villageOtherNumProportion)) {
                map.put("villageOtherNumProportion", "0.00%");
            } else {
                map.put("villageOtherNumProportion", villageOtherNumProportion);
            }
            //农村其他面积
            map.put("villageHouseOtherArea", villageHouseOtherArea + villagePubHouseOtherArea);
            //农村其他面积占比
            if (StringUtils.isEmpty(villageOtherAreaProportion)) {
                map.put("villageOtherAreaProportion", "0.00%");
            } else {
                map.put("villageOtherAreaProportion", villageOtherAreaProportion);
            }
            try {
                WordUtil.exportMillCertificateWord(request, response, map, "数据采集报告（详查）", "20200512-数据采集报告（详查）.ftl");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }


    }



    @Override
    public List<Map> wideColTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"砼柱", "砖柱", "钢柱", "其他"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String coltype : array) {
            // 查询参数变化
            analysisQueryVo.setColType(coltype);
            // 柱类型数量
            long count = fwWideStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", coltype);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideColTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"砼柱", "砖柱", "钢柱", "其他"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String coltype : array) {
            // 查询参数变化
            analysisQueryVo.setColType(coltype);
            // 柱类型面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", coltype);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideColSpanNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{Constant.LESS_18, Constant.BETWEEN_18_36, Constant.BETWEEN_36_60, Constant.MORE_60};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String colSpan : array) {
            // 查询参数变化
            analysisQueryVo.setColSpan(colSpan);
            // 数量
            long count = fwWideStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", colSpan);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideColSpanArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{Constant.LESS_18, Constant.BETWEEN_18_36, Constant.BETWEEN_36_60, Constant.MORE_60};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String colSpan : array) {
            // 查询参数变化
            analysisQueryVo.setColSpan(colSpan);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", colSpan);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideColSpaceNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{Constant.LESS_6, Constant.BETWEEN_6_9, Constant.MORE_9};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String colSpace : array) {
            // 查询参数变化
            analysisQueryVo.setColSpace(colSpace);
            // 数量
            long count = fwWideStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", colSpace);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideColSpaceArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{Constant.LESS_6, Constant.BETWEEN_6_9, Constant.MORE_9};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String colSpace : array) {
            // 查询参数变化
            analysisQueryVo.setColSpace(colSpace);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", colSpace);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideWmTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有檩屋盖", "无檩屋盖"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wmType : array) {
            // 查询参数变化
            analysisQueryVo.setWmType(wmType);
            // 数量
            long count = fwWideStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wmType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideWmTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有檩屋盖", "无檩屋盖"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wmType : array) {
            // 查询参数变化
            analysisQueryVo.setWmType(wmType);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wmType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideWjGenreNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"实腹钢梁", "钢桁架", "钢网架", "木屋架", "钢屋架"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wjGenre : array) {
            // 查询参数变化
            analysisQueryVo.setWjGenre(wjGenre);
            // 数量
            long count = fwWideStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wjGenre);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideWjGenreArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"实腹钢梁", "钢桁架", "钢网架", "木屋架", "钢屋架"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wjGenre : array) {
            // 查询参数变化
            analysisQueryVo.setWjGenre(wjGenre);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wjGenre);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideRingBeamNum(AnalysisQueryVo analysisQueryVo) {
        // 1、2、3、>3
        String[] array = new String[]{"1","2","3",">3"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String ringBeamNum : array) {
            // 查询参数变化
            analysisQueryVo.setRingBeamNum(ringBeamNum);
            // 数量
            long count = fwWideStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", ringBeamNum);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> wideRingBeamArea(AnalysisQueryVo analysisQueryVo) {
        // 1、2、3、>3
        String[] array = new String[]{"1","2","3",">3"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String ringBeamNum : array) {
            // 查询参数变化
            analysisQueryVo.setRingBeamNum(ringBeamNum);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", ringBeamNum);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWallTypeNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体类型（夯土墙,土坯墙）
        String[] array = new String[]{"夯土墙", "土坯墙"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallType : array) {
            // 查询参数变化
            analysisQueryVo.setWallType(wallType);
            // 面积
            long count = fwBuildingStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWallTypeArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体类型（夯土墙,土坯墙）
        String[] array = new String[]{"夯土墙", "土坯墙"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallType : array) {
            // 查询参数变化
            analysisQueryVo.setWallType(wallType);
            // 面积
            double count = fwBuildingStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingQtyxclNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体延性材料(无,竹筋木条荆条,草筋)
        String[] array = new String[]{"无", "竹筋木条荆条", "草筋"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String qtyxcl : array) {
            // 查询参数变化
            analysisQueryVo.setQtyxcl(qtyxcl);
            // 数量
            long count = fwBuildingStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", qtyxcl);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingQtyxclArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体延性材料(无,竹筋木条荆条,草筋)
        String[] array = new String[]{"无", "竹筋木条荆条", "草筋"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String qtyxcl : array) {
            // 查询参数变化
            analysisQueryVo.setQtyxcl(qtyxcl);
            // 面积
            long count = fwBuildingStructureService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", qtyxcl);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWallThickNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{Constant.LESS_120, Constant.BETWEEN_120_240, Constant.BETWEEN_240_360, Constant.MORE_360};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallThick : array) {
            // 查询参数变化
            analysisQueryVo.setWallThick(wallThick);
            // 数量
            long count = fwBuildingStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallThick);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWallThickArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{Constant.LESS_120, Constant.BETWEEN_120_240, Constant.BETWEEN_240_360, Constant.MORE_360};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallThick : array) {
            // 查询参数变化
            analysisQueryVo.setWallThick(wallThick);
            // 数量
            long count = fwBuildingStructureService.areaCount(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallThick);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWindowWidthNum(AnalysisQueryVo analysisQueryVo) {
        // 门窗洞口宽度（大于1.5m,小于1.5m）
        String[] array = new String[]{Constant.MORE_ONE_AND_HALF, Constant.LESS_ONE_AND_HALF};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String windowWidth : array) {
            // 查询参数变化
            analysisQueryVo.setWindowWidth(windowWidth);
            // 数量
            long count = fwBuildingStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", windowWidth);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWindowWidthArea(AnalysisQueryVo analysisQueryVo) {
        // 门窗洞口宽度（大于1.5m,小于1.5m）
        String[] array = new String[]{Constant.MORE_ONE_AND_HALF, Constant.LESS_ONE_AND_HALF};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String windowWidth : array) {
            // 查询参数变化
            analysisQueryVo.setWindowWidth(windowWidth);
            // 数量
            double count = fwBuildingStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", windowWidth);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWmMaterialNum(AnalysisQueryVo analysisQueryVo) {
        // 屋面材料（轻屋面,重屋面）
        String[] array = new String[]{"轻屋面", "重屋面"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wmMaterial : array) {
            // 查询参数变化
            analysisQueryVo.setWmMaterial(wmMaterial);
            // 数量
            long count = fwBuildingStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wmMaterial);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWmMaterialArea(AnalysisQueryVo analysisQueryVo) {
        // 屋面材料（轻屋面,重屋面）
        String[] array = new String[]{"轻屋面", "重屋面"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wmMaterial : array) {
            // 查询参数变化
            analysisQueryVo.setWmMaterial(wmMaterial);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wmMaterial);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWallRingBeamNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体圈梁（有圈梁,无圈梁）
        String[] array = new String[]{"有圈梁", "无圈梁"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallRingBeam : array) {
            // 查询参数变化
            analysisQueryVo.setWallRingBeam(wallRingBeam);
            // 数量
            long count = fwBuildingStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallRingBeam);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> buildingWallRingBeamArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体圈梁（有圈梁,无圈梁）
        String[] array = new String[]{"有圈梁", "无圈梁"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallRingBeam : array) {
            // 查询参数变化
            analysisQueryVo.setWallRingBeam(wallRingBeam);
            // 面积
            double count = fwWideStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallRingBeam);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodCdTypeNum(AnalysisQueryVo analysisQueryVo) {
        // 穿斗方式(横向穿斗贯穿整榀构架,无穿斗)
        String[] array = new String[]{"横向穿斗贯穿整榀构架", "无穿斗"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String cdType : array) {
            // 查询参数变化
            analysisQueryVo.setCdType(cdType);
            // 数量
            long count = fwWoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", cdType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodCdTypeArea(AnalysisQueryVo analysisQueryVo) {
        // 穿斗方式(横向穿斗贯穿整榀构架,无穿斗)
        String[] array = new String[]{"横向穿斗贯穿整榀构架", "无穿斗"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String cdType : array) {
            // 查询参数变化
            analysisQueryVo.setCdType(cdType);
            // 面积
            double count = fwWoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", cdType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodMzsjNum(AnalysisQueryVo analysisQueryVo) {
        // 木柱梢径(大于150mm,小于等于150mm)
        String[] array = new String[]{"大于150mm", "小于等于150mm"};
        ArrayList<Map> result = new ArrayList<>();
        for (String mzsj : array) {
            // 查询参数变化
            analysisQueryVo.setMzsj(mzsj);
            // 数量
            long count = fwWoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", mzsj);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodMzsjArea(AnalysisQueryVo analysisQueryVo) {
        // 木柱梢径(大于150mm,小于等于150mm)
        String[] array = new String[]{"大于150mm", "小于等于150mm"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String mzsj : array) {
            // 查询参数变化
            analysisQueryVo.setMzsj(mzsj);
            // 面积
            double count = fwWoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", mzsj);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodWallTypeNum(AnalysisQueryVo analysisQueryVo) {
        // 围护墙体类型（土墙,砖墙,木板墙）
        String[] array = new String[]{"土墙", "砖墙", "木板墙"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallType : array) {
            // 查询参数变化
            analysisQueryVo.setWallType(wallType);
            // 数量
            long count = fwWoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodWallTypeArea(AnalysisQueryVo analysisQueryVo) {
        // 围护墙体类型（土墙,砖墙,木板墙）
        String[] array = new String[]{"土墙", "砖墙", "木板墙"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallType : array) {
            // 查询参数变化
            analysisQueryVo.setWallType(wallType);
            // 面积
            double count = fwWoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodSjqtTypeNum(AnalysisQueryVo analysisQueryVo) {
        // 山尖墙体类型(土墙,砖墙,木板墙)
        String[] array = new String[]{"土墙", "砖墙", "木板墙"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String sjqtType : array) {
            // 查询参数变化
            analysisQueryVo.setSjqtType(sjqtType);
            // 数量
            long count = fwWoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", sjqtType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodSjqtTypeArea(AnalysisQueryVo analysisQueryVo) {
        // 山尖墙体类型(土墙,砖墙,木板墙)
        String[] array = new String[]{"土墙", "砖墙", "木板墙"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String sjqtType : array) {
            // 查询参数变化
            analysisQueryVo.setSjqtType(sjqtType);
            // 面积
            double count = fwWoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", sjqtType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodWallThickNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体厚度（按照≤120mm，120-240mm，240-360mm，≥360mm统计占比）
        String[] array = new String[]{Constant.LESS_120, Constant.BETWEEN_120_240, Constant.BETWEEN_240_360, Constant.MORE_360};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallThick : array) {
            // 查询参数变化
            analysisQueryVo.setWallThick(wallThick);
            // 数量
            long count = fwWoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallThick);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodWallThickArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体厚度（按照≤120mm，120-240mm，240-360mm，≥360mm统计占比）
        String[] array = new String[]{Constant.LESS_120, Constant.BETWEEN_120_240, Constant.BETWEEN_240_360, Constant.MORE_360};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallThick : array) {
            // 查询参数变化
            analysisQueryVo.setWallThick(wallThick);
            // 面积
            double count = fwWoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallThick);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodWallRingBeamNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体圈梁（有圈梁,无圈梁）
        String[] array = new String[]{"有圈梁", "无圈梁"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallRingBeam : array) {
            // 查询参数变化
            analysisQueryVo.setWallRingBeam(wallRingBeam);
            // 数量
            long count = fwWoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallRingBeam);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> woodWallRingBeamArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体圈梁（有圈梁,无圈梁）
        String[] array = new String[]{"有圈梁", "无圈梁"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallRingBeam : array) {
            // 查询参数变化
            analysisQueryVo.setWallRingBeam(wallRingBeam);
            // 面积
            double count = fwWoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallRingBeam);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneWallMaterialNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体材质-普通砖、多孔砖、砌块、其他
        String[] array = new String[]{"普通砖", "多孔砖", "砌块", "其他"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallMaterial : array) {
            // 查询参数变化
            analysisQueryVo.setWallMaterial(wallMaterial);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallMaterial);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneWallMaterialArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体材质-普通砖、多孔砖、砌块、其他
        String[] array = new String[]{"普通砖", "多孔砖", "砌块", "其他"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallMaterial : array) {
            // 查询参数变化
            analysisQueryVo.setWallMaterial(wallMaterial);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallMaterial);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneHqzdSpaceNum(AnalysisQueryVo analysisQueryVo) {
        // 横墙最大间距
        String[] array = new String[]{Constant.LESS_3, Constant.BETWEEN_3_5, Constant.BETWEEN_5_7, Constant.BETWEEN_7_9, Constant.MORE_9};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String hqzdSpace : array) {
            // 查询参数变化
            analysisQueryVo.setHqzdSpace(hqzdSpace);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", hqzdSpace);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneHqzdSpaceArea(AnalysisQueryVo analysisQueryVo) {
        // 横墙最大间距
        String[] array = new String[]{Constant.LESS_3, Constant.BETWEEN_3_5, Constant.BETWEEN_5_7, Constant.BETWEEN_7_9, Constant.MORE_9};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String hqzdSpace : array) {
            // 查询参数变化
            analysisQueryVo.setHqzdSpace(hqzdSpace);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", hqzdSpace);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneWallThickNum(AnalysisQueryVo analysisQueryVo) {
        // 墙体厚度（按照≤120mm，120-240mm，240-360mm，≥360mm统计占比）
        String[] array = new String[]{Constant.LESS_120, Constant.BETWEEN_120_240, Constant.BETWEEN_240_360, Constant.MORE_360};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallThick : array) {
            // 查询参数变化
            analysisQueryVo.setWallThick(wallThick);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallThick);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneWallThickArea(AnalysisQueryVo analysisQueryVo) {
        // 墙体厚度（按照≤120mm，120-240mm，240-360mm，≥360mm统计占比）
        String[] array = new String[]{Constant.LESS_120, Constant.BETWEEN_120_240, Constant.BETWEEN_240_360, Constant.MORE_360};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String wallThick : array) {
            // 查询参数变化
            analysisQueryVo.setWallThick(wallThick);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", wallThick);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneHqkdAreaNum(AnalysisQueryVo analysisQueryVo) {
        // 横墙开洞面积  大于水平全截面1/3,小于水平全截面1/3
        String[] array = new String[]{"大于水平全截面1/3", "小于水平全截面1/3"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String hqkdArea : array) {
            // 查询参数变化
            analysisQueryVo.setHqkdArea(hqkdArea);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", hqkdArea);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneHqkdAreaArea(AnalysisQueryVo analysisQueryVo) {
        // 横墙开洞面积  大于水平全截面1/3,小于水平全截面1/3
        String[] array = new String[]{"大于水平全截面1/3", "小于水平全截面1/3"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String hqkdArea : array) {
            // 查询参数变化
            analysisQueryVo.setHqkdArea(hqkdArea);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", hqkdArea);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneRoofTypeNum(AnalysisQueryVo analysisQueryVo) {
        // 屋盖类别
        String[] array = new String[]{"木屋盖", "现浇屋盖", "预制板", "彩钢板", "其他"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String roofType : array) {
            // 查询参数变化
            analysisQueryVo.setRoofType(roofType);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", roofType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneRoofTypeArea(AnalysisQueryVo analysisQueryVo) {
        // 屋盖类别
        String[] array = new String[]{"木屋盖", "现浇屋盖", "预制板", "彩钢板", "其他"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String roofType : array) {
            // 查询参数变化
            analysisQueryVo.setRoofType(roofType);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", roofType);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stonQlNum(AnalysisQueryVo analysisQueryVo) {
        // 圈梁
        String[] array = new String[]{"有圈梁", "无圈梁"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String ql : array) {
            // 查询参数变化
            analysisQueryVo.setQl(ql);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", ql);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneQlArea(AnalysisQueryVo analysisQueryVo) {
        // 圈梁
        String[] array = new String[]{"有圈梁", "无圈梁"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String ql : array) {
            // 查询参数变化
            analysisQueryVo.setQl(ql);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", ql);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stonSjsgzzNum(AnalysisQueryVo analysisQueryVo) {
        // 四角设构造柱
        String[] array = new String[]{"0（无）", "1（有）"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String sjsgzz : array) {
            // 查询参数变化
            analysisQueryVo.setSjsgzz(sjsgzz);
            // 数量
            long count = fwStoneStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", sjsgzz);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> stoneSjsgzzArea(AnalysisQueryVo analysisQueryVo) {
        // 四角设构造柱
        String[] array = new String[]{"0（无）", "1（有）"};
        // 饼数据
        ArrayList<Map> result = new ArrayList<>();
        for (String sjsgzz : array) {
            // 查询参数变化
            analysisQueryVo.setSjsgzz(sjsgzz);
            // 面积
            double count = fwStoneStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", sjsgzz);
            result.add(map);
        }
        return result;
    }

    @Override
    public List<Map> brickwoodOutWallThickNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setOutWallThick(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodOutWallThickArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setOutWallThick(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodInWallThickNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setInWallThick(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodInWallThickArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setInWallThick(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodWallMaterialNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"普通砖","多孔砖","砌块","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setWallMaterial(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodWallMaterialArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"普通砖","多孔砖","砌块","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setWallMaterial(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodMortarTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"水泥砂浆","混合砂浆","泥浆"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarType(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodMortarTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"水泥砂浆","混合砂浆","泥浆"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarType(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodMortarStrengthNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"大于等于M2.5","小于M2.5"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarStrength(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodMortarStrengthArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"大于等于M2.5","小于M2.5"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarStrength(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodRoofTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodRoofTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodFloorTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodFloorTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodJlInstallNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"0（未设圈梁）","1（屋盖处设圈梁）","2（隔层设圈梁）","3（层层设圈梁）"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlInstall(arr);
            long count = fwBrickwoodStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickwoodJlInstallArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"0（未设圈梁）","1（屋盖处设圈梁）","2（隔层设圈梁）","3（层层设圈梁）"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlInstall(arr);
            double count = fwBrickwoodStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherJlqhntqdLevelNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqhntqdLevel(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherJlqhntqdLevelArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqhntqdLevel(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherShearwellThicknessNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=160mm","160mm-200mm","200mm-400mm","400mm-700mm",">=700m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setShearwellThickness(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherShearwellThicknessArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=160mm","160mm-200mm","200mm-400mm","400mm-700mm",">=700m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setShearwellThickness(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherJlqzdSpanNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=30m","30m-40m","40m-50m","50m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqzdSpan(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherJlqzdSpanArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=30m","30m-40m","40m-50m","50m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqzdSpan(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherMortarTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"水泥砂浆","混合砂浆","泥浆"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarType(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherMortarTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"水泥砂浆","混合砂浆","泥浆"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarType(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherWallMaterialNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"普通砖","多孔砖","砌块","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setWallMaterial(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherWallMaterialArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"普通砖","多孔砖","砌块","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setWallMaterial(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherFloorTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherFloorTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherRoofTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            long count = fwOtherStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> otherRoofTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            double count = fwOtherStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickOutWallThickNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setOutWallThick(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickOutWallThickArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setOutWallThick(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickInWallThickNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setInWallThick(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickInWallThickArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=120mm","120mm-240mm","240mm-370mm",">=370mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setInWallThick(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickWallMaterialNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"普通砖","多孔砖","砌块","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setWallMaterial(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickWallMaterialArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"普通砖","多孔砖","砌块","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setWallMaterial(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickMortarTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"水泥砂浆","混合砂浆","泥浆"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarType(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickMortarTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"水泥砂浆","混合砂浆","泥浆"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarType(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickMortarStrengthNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"大于等于M2.5","小于M2.5"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarStrength(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickMortarStrengthArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"大于等于M2.5","小于M2.5"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setMortarStrength(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickRoofTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickRoofTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickFloorTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickFloorTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickJlInstallNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"0（未设圈梁）","1（屋盖处设圈梁）","2（隔层设圈梁）","3（层层设圈梁）"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlInstall(arr);
            long count = fwBrickStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> brickJlInstallArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"0（未设圈梁）","1（屋盖处设圈梁）","2（隔层设圈梁）","3（层层设圈梁）"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlInstall(arr);
            double count = fwBrickStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulZhntqdLevelNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZhntqdLevel(arr);
            long count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulZhntqdLevelArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZhntqdLevel(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulZyzjmSizeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=300mm","300mm-400mm","400mm-600mm",">=600"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZyzjmSize(arr);
            long count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulZyzjmSizeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=300mm","300mm-400mm","400mm-600mm",">=600"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZyzjmSize(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulZdzSpanNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=5m","5m-8m","8m-10m",">=10m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZdzSpan(arr);
            long count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulZdzSpanArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=5m","5m-8m","8m-10m",">=10m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZdzSpan(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulJlqhntqdLevelNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqhntqdLevel(arr);
            long count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulJlqhntqdLevelArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqhntqdLevel(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulJlqzdSpanNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=30m","30m-40m","40m-50m","50m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqzdSpan(arr);
            long count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulJlqzdSpanArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=30m","30m-40m","40m-50m","50m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqzdSpan(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulShearwellThicknessNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=160mm","160mm-200mm","200mm-300mm",">=300mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setShearwellThickness(arr);
            long count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulShearwellThicknessArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=160mm","160mm-200mm","200mm-300mm",">=300m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setShearwellThickness(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulRoofTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            float count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulRoofTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulFloorTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            float count = fwMulConcreteStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> mulFloorTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            double count = fwMulConcreteStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightZhntqdLevelNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZhntqdLevel(arr);
            float count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightZhntqdLevelArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZhntqdLevel(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightZyzjmSizeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=300mm","300mm-400mm","400mm-600mm",">=600mm"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZyzjmSize(arr);
            float count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightZyzjmSizeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=300mm","300mm-400mm","400mm-600mm",">=600"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZyzjmSize(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightZdzSpanNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=5m","5m-8m","8m-10m",">=10m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZdzSpan(arr);
            long count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightZdzSpanArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=5m","5m-8m","8m-10m",">=10m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setZdzSpan(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightJlqhntqdLevelNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqhntqdLevel(arr);
            long count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightJlqhntqdLevelArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"无","C15","C20","C25","C30","C35","C40","C45","C50","C55","C60","C65","C70","C75","C80","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqhntqdLevel(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightJlqzdSpanNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=30m","30m-40m","40m-50m","50m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqzdSpan(arr);
            long count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightJlqzdSpanArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=30m","30m-40m","40m-50m","50m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setJlqzdSpan(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightShearwellThicknessNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=160mm","160mm-200mm","200mm-400mm","400mm-700mm",">=700m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setShearwellThickness(arr);
            long count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightShearwellThicknessArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=160mm","160mm-200mm","200mm-400mm","400mm-700mm",">=700m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setShearwellThickness(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightRoofTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            long count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightRoofTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木屋盖","现浇屋盖","预制板","彩钢板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofType(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightFloorTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            long count = fwHighStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> heightFloorTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"木楼板","现浇楼板","预制板","其他"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setFloorType(arr);
            double count = fwHighStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryBentFrameColTypeNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"钢柱","砼柱","砖柱","砼预制柱"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setBentFrameColType(arr);
            long count = fwFactoryStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryBentFrameColTypeArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=18mm","18m-36m","36m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setBentFrameColType(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factorySpansNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=18mm","18m-36m","36m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setSpans(arr);
            long count = fwFactoryStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factorySpansArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=18mm","18m-36m","36m-60m",">=60m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setSpans(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryBentFrameColSpaceNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=6m","6m-9m",">=9m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setBentFrameColSpace(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryBentFrameColSpaceArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"<=6m","6m-9m",">=9m"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setBentFrameColSpace(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryRoofSystemNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有檩屋盖","无檩屋盖"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofSystem(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryRoofSystemArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"有檩屋盖","无檩屋盖"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofSystem(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryRoofTrussStyleNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"实腹钢梁","钢桁架","钢网架","木屋架","钢屋架"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofTrussStyle(arr);
            long count = fwFactoryStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryRoofTrussStyleArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"实腹钢梁","钢桁架","钢网架","木屋架","钢屋架"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRoofTrussStyle(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryRingBeamNumNum(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"1","2","3",">3"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRingBeamNum(arr);
            long count = fwFactoryStructureService.count(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

    @Override
    public List<Map> factoryRingBeamNumArea(AnalysisQueryVo analysisQueryVo) {
        String[] array = new String[]{"1","2","3",">3"};
        ArrayList<Map> resultCount = new ArrayList<>();
        for (String arr:array) {
            analysisQueryVo.setRingBeamNum(arr);
            double count = fwFactoryStructureService.area(analysisQueryVo);
            HashMap<String, Object> map = new HashMap<>();
            map.put("value", count);
            map.put("name", arr);
            resultCount.add(map);
        }
        return resultCount;
    }

}
